#
# =================================================================================================
#
#
#
#
#
# =================================================================================================
# -------------------------------------------------------------------------------------------------
# Public API
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Standard Imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Scope4Xi imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Multiprocessing Imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# DragonXi imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Global constants
# ------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Settings
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def trace2image4epu(task4trace2epu=None):
'''
creates callback to epu2image4xi
'''
global epu2trace4xi
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "trace2image4epu"
method2print = "trace2image4epu"
message2print = "{(Step 1A/33) started" + "; trace2image4epu-started: " + str(trace2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1B/33) passed" + "; task4trace2epu-to-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
# None
code2ack = ' '
code2nack = ' '
epu2trace4xi = {} # INITIALIZES TO EMPTY DICTIONARY
if task4trace2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY EPUIZED CALLBACK !
# -----------------------------------------------------------------------------------------
task4trace2epu = {}
task4trace2epu['CLASS'] = "trace2image4epu" # EPUIZE ZPU TRACE!
task4trace2epu['METHOD'] = "trace2image4epu"
task4trace2epu['MESSAGE'] = "{(Step 2Z0/33) failed" + "; trace2image4epu-failed " + str(epu2trace4xi) + "; time: " + time4xi() + "}"
message2print = "{(Step 2A/33) set" + "; task4trace2epu-set-by-trace2image4epu to: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 08:14:33 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu',
# 'METHOD': 'trace2image4epu'}
# ; time: 08:14:33 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '2A-'
# -----------------------------------------------------------------------------------------
# PARAMETER GIVEN BY EPUIZED CALLBACK !
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) try" + "; task4trace2epu-try-by-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# { trace2image4epu : trace2image4epu ; (Step 3A/33) try; task4trace2epu-try-by-trace2image4epu:
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 08:14:33 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu',
# 'METHOD': 'trace2image4epu'}
# ; time: 08:14:33 09/06/11 Pacific Daylight Time}
try:
epu2trace4xi ['CLASS'] = task4trace2epu['CLASS'] # EPUIZE EPU TRACE!
epu2trace4xi ['METHOD'] = task4trace2epu['METHOD']
epu2trace4xi ['MESSAGE'] = task4trace2epu['MESSAGE']
message2print = "{(Step 3B/33) set" + "; epu2trace4xi-set-by-trace2image4epu to: " + str(epu2trace4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# { trace2image4epu : trace2image4epu ; (Step 3B/33) set; epu2trace4xi-set-by-trace2image4epu to:
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 23:41:37 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu',
# 'METHOD': 'trace2image4epu'}
# ; time: 23:41:37 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z1/33) failed" + "; epu-trace-failed-by-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
try:
# =================================
# SIMULATE EPU TRACE
# =================================
class2print = task4trace2epu['CLASS'] # EPUIZE EPU TRACE!
method2print = task4trace2epu['METHOD']
message2print = task4trace2epu['MESSAGE']
print4xi(class2print, method2print, message2print) # EPUIZED TRACE FOR OPENCL CALLBACK!
# { trace2image4epu : trace2image4epu ; (Step 2Z0/33) failed; trace2image4epu-failed {}; time: 23:41:37 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '3C-'
except:
class2print = "trace2image4epu" # SET TRACE BACK TO THIS FUNCTION!
method2print = "trace2image4epu"
message2print = "{(Step 3Z2/33) failed" + "; simulation-of-epu-trace-failed-by-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z2-'
try:
# =================================
# NORMAL TRACE
# =================================
class2print = "trace2image4epu" # SET TRACE BACK TO THIS FUNCTION!
method2print = "trace2image4epu"
message2print = "{(Step 3D/33) performed" + "; epu-trace-performed-by-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# { trace2image4epu : trace2image4epu ; (Step 3D/33) performed; epu-trace-performed-by-trace2image4epu:
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 23:41:37 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu', 'METHOD': 'trace2image4epu'}; time: 23:41:37 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '3D-'
except:
message2print = "{(Step 3Z3/33) failed" + "; epu-trace-failed-by-trace2image4epu: " + str(task4trace2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z3-'
# -----------------------------------------------------------------------------------------
# (Step 33/3)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 33/33) returning" + "; epu2trace4xi-returning-by-trace2image4epu: " + str(epu2trace4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 23:41:37 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu',
# 'METHOD': 'trace2image4epu'}; time: 23:41:37 09/06/11 Pacific Daylight Time}
return epu2trace4xi
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def set2imagecallback4epu(task4set2imagecallback=None):
'''
registers callback function to epu2image4xi
'''
global epu2image4xi
class2print = "set2imagecallback4epu"
method2print = "set2imagecallback4epu"
message2print = "{(Step 1A/70) started" + "; set2imagecallback4epu-started: " + str(set2imagecallback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
epu2image4xi ['CALLBACK'] = trace2image4epu
message2print = "{(Step 1B/70) set callback2epu" + "; imagecallback4epu-set-by-set2imagecallback4epu: " + str(epu2image4xi ['CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1C/70) returning" + "; callback-of-epu2image4xi-returning-by-set2imagecallback4epu: " + str(epu2image4xi ['CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
return epu2image4xi ['CALLBACK']
except:
message2print = "{(Step 1Z1/70) failed" + "; callback2image-failed-by-set2imagecallback4epu: " + str(callback2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 1Z2/70) returning" + "; trace2image4epu-returning-by-set2imagecallback4epu: " + str(trace2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
return trace2image4epu
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def create2image4epu(task4imagecreate2epu=None):
'''
creates 2D image for EPU
'''
global epu2image4xi
# -----------------------------------------------------------------------------------------
# (Step 1/70) - CHECK PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "create2image4epu"
method2print = "create2image4epu"
message2print = "{(Step 1A/70) started" + "; create2image4epu-started: " + str(create2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1B/70) passed" + "; task4imagecreate2epu-to-create2image4epu: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
epu2image4xi = {} # INITIALIZES TO EMPTY DICTIONARY
try:
if task4imagecreate2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR CREATION - BUILD TASK TO EPU!
# -----------------------------------------------------------------------------------------
task4imagecreate2epu = {}
message2print = "{(Step 1C/70) initialized" + "; task4imagecreate2epu-created-by-create2image4epu to: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1D/70) initialized" + "; function2callback4epu-created-by-create2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1D-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "create2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "create2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; create2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1E/70) initialized" + "; args2callback-created-by-create2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 00:54:15 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'}; time: 00:54:15 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '1E-'
# ---------------------------------------------------------------------------------------------
# (1) CALLBACKS - EXTRA
# ---------------------------------------------------------------------------------------------
task4imagecreate2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagecreate2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '2C-'
message2print = "{(Step 1F/70) initialized" + "; task4imagecreate2epu-created-by-create2image4epu to: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 00:54:15 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'}}; time: 00:54:15 09/06/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - EXTRA
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-create2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-create2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}; time: 00:54:15 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-create2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4imagecreate2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - REQUIRED
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-create2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-create2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 00:54:15 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0, 'PROPERTIES': None}; time: 00:54:15 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-create2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4imagecreate2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - EXTRA
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-create2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-create2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2,
# 'MAX2UNITS4COMPUTE': 4,
# 'SIZE2MEMORY4GLOBAL': 3221225472,
# 'NATIVE2WIDTHFLOAT4VECTOR': 4,
# 'MAX2SIZE4WORKGROUP': 1024,
# 'PREFERRED2WIDTHCHAR4VECTOR': 16,
# 'SIZE2CACHE': 65536,
# 'IEEE754-2008FUSED2MULTIPLY-ADD': 'NACK',
# 'TYPE4CACHE': 'Read/Write',
# 'PREFERRED2WIDTHINT4VECTOR': 4,
# 'SIZE2PREFERREDWORKGROUPMULTIPLE4KERNEL': 1,
# 'NATIVE2WIDTHINT4VECTOR': 4,
# 'SIZE2BUFFER4CONSTANT': 65536,
# 'EXECUTE2FUNCTION4NATIVE': 'ACK',
# 'PREFERRED2WIDTHDOUBLE4VECTOR': 0,
# 'MAX2NUMBER4CONSTANTARGS': 8,
# 'VERSION2DRIVER': '2.0',
# 'EXTENSIONS': 'cl_amd_fp64 cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics
# 'AVAILABLE2COMPILER': 'ACK',
# 'MAX2DIMENSIONS4WORKITEMS': 3,
# 'SUPPORT2CORRECTION4ERROR': 0,
# 'BITS2ADDRESS': 64,
# 'AVAILABLE': 'ACK',
# 'SIZE2MEMORY4LOCAL': 32768,
# 'VENDOR': 'AuthenticAMD',
# 'SUPPORT2IMAGE': 'NACK',
# 'MAX2SIZE4KERNELARGUMENT': 4096,
# 'ACK2RETURN': ' 1C-1D-1E-1F-1D-2A-
# 'OUT-OF-ORDER2QUEUE': 'NACK',
# 'ALIGNMENT2ADDRESS4BASE': 1024,
# 'PROFILE': 'FULL_PROFILE',
# 'TYPE2MEMORY4LOCAL': 'Global',
# 'PREFERRED2WIDTHFLOAT4VECTOR': 4,
# 'PREFERRED2WIDTHLONG4VECTOR': 2,
# 'MAX2FREQUENCY4CLOCK': 3210,
# 'PREFERRED2WIDTHSHORT4VECTOR': 8,
# 'ID': 4033,
# 'MAX2WORKITEM2': 1024,
# 'NATIVE2WIDTHDOUBLE4VECTOR': 0,
# 'ROUND2ZERO': 'ACK',
# 'NAME': 'AMD64 Family 16 Model 4 Stepping 2, AuthenticAMD',
# 'MAX2WORKITEM1': 1024,
# 'MAX2WORKITEM0': 1024,
# 'SIZE2LINE4CACHE': 64,
# 'MAX2ALLOCATION4MEMORY': 1073741824,
# 'NATIVE2WIDTHCHAR4VECTOR': 16,
# 'QUIET2NANS': 'ACK',
# 'NATIVE2WIDTHSHORT4VECTOR': 8,
# 'ROUND2NEAREST4EVEN': 'ACK',
# 'VERSION': 'OpenCL 1.1 ATI-Stream-v2.3 (451)',
# 'NACK2RETURN': ' ',
# 'MEMORY2UNIFIED4HOSTANDDEVICE': 1,
# 'ENDIANESS2DEVICE': 'Little',
# 'MINIMUM2ALIGNMENT4DATATYPE': 128,
# 'ROUND2+VE3INFINITY': 'ACK',
# 'TYPE': 'CL_DEVICE_TYPE_EPU',
# 'DENORMS2SINGLEPRECISION4FLOATINGPOINTCAPABILITY': 'ACK'}; time: 00:54:15 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-create2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4imagecreate2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) ERROR CODE - REQUIRED
# ---------------------------------------------------------------------------------------------
task4imagecreate2epu ['CODE2ERROR'] = 0
code2ack = code2ack + '5B-'
# ---------------------------------------------------------------------------------------------
# (6) QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 6A/70) trying" + "; queue2epu-trying-by-create2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 6B/70) got" + "; queue2epu-got-by-create2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; queue2epu-failed-by-create2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4imagecreate2epu ['QUEUE'] = queue2epu
# ---------------------------------------------------------------------------------------------
# (7) PIPE - EXTRA
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 7A/70) trying" + "; pipe2epu-trying-by-create2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 7B/70) got" + "; pipe2epu-got-by-create2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; pipe2epu-failed-by-create2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4imagecreate2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (8) COMMAND QUEUE INFO - EXTRA
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 8A/70) trying" + "; commandqueueinfo2epu-trying-by-create2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 8B/70) got" + "; commandqueueinfo2epu-got-by-create2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 05:04:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-8A-9B-10B-9B-10B-11B-12B-13B-14B-15B-16B-17B-18B-',
# 'INFO2PRIVATE': None,
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0 ...
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 05:04:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'DEVICE': {'RESOLUTION2TIMER4PROFILING': 318, ...
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; commandqueueinfo2epu-failed-by-create2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4imagecreate2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (9) BUFFER INFO - EXTRA
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; bufferinfo2epu-trying-by-create2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; bufferinfo2epu-got-by-create2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 05:04:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 05:04:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'DEVICE': {'RESOLUTION2TIMER4PROFILING': 318, ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; bufferinfo2epu-failed-by-create2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4imagecreate2epu ['BUFFER'] = bufferinfo2epu
# ---------------------------------------------------------------------------------------------
# (10) EVENT INFO - EXTRA
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 10A/70) trying" + "; eventinfo2epu-trying-by-create2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu() # SYSTEM CREATES EVENT IF NECESSAY
message2print = "{(Step 10B/70) got" + "; eventinfo2epu-got-by-create2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4epu-failed ; time: 05:10:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2event4epu',
# 'METHOD': 'create2event4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-',
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 05:10:51 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu', 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'COMMANDQUEUE': {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': ...
code2ack = code2ack + '10B-'
except:
message2print = "{(Step 10Z/70) failed" + "; eventinfo2epu-failed-by-create2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '10Z-'
task4imagecreate2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) FLAGS - REQUIRED
# ---------------------------------------------------------------------------------------------
flags2epu = 0
message2print = "{(Step 11A/70) trying" + "; flags2epu-trying-by-create2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
flags2epu = 0
message2print = "{(Step 11B/70) set" + "; flags2epu-set-by-create2image4epu to: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; flags2epu-failed-by-create2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4imagecreate2epu ['FLAGS'] = flags2epu
# ---------------------------------------------------------------------------------------------
# (14) WIDTH - REQUIRED
# ---------------------------------------------------------------------------------------------
width2epu = 0
quantity2core = 1 # ORIGIN
quantity2skeleton = 1 # SKELETON WITH DISTANCE 1
quantity2layers = 33 # LAYERS 10, 100 ... 900, 1000 ... 3300
quantity2frame = 1 # FRAME
quantity2extra = 4 # CONTROLS FOR GUI ETC...
width2layer = 10 # SCALED TO 10 EACH LAYER
message2print = "{(Step 14A/70) trying" + "; width2epu-trying-by-create2image4epu: " + str(width2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
width2epu = int(width2layer * (quantity2core + quantity2skeleton + quantity2layers + quantity2frame + quantity2extra))
width2epu = 2 * width2epu # POS and NEG X 2*400 = 800 PIXELS
message2print = "{(Step 14B/70) set" + "; width2epu-set-by-create2image4epu to: " + str(width2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; width2epu-failed-by-create2image4epu: " + str(width2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4imagecreate2epu ['WIDTH'] = width2epu
# ---------------------------------------------------------------------------------------------
# (15) HEIGHT - REQUIRED
# ---------------------------------------------------------------------------------------------
height2epu = 0
quantity2core = 1 # ORIGIN
quantity2skeleton = 1 # SKELETON WITH DISTANCE 1
quantity2layers = 33 # LAYERS 10, 100 ... 900, 1000 ... 3300
quantity2frame = 1 # FRAME
quantity2extra = 4 # CONTROLS FOR GUI
quantity2total = quantity2core + quantity2skeleton + quantity2layers + quantity2frame + quantity2extra
height2layer = 10 # SCALED TO 10
message2print = "{(Step 15A/70) trying" + "; height2epu-trying-by-create2image4epu: " + str(height2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
height2epu = height2layer * quantity2total
height2epu = 2 * height2epu # POS and NEG Y 2*400 = 800 PIXELS
message2print = "{(Step 15B2/70) set" + "; height2epu-set-by-create2image4epu to: " + str(height2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; height2epu-failed-by-create2image4epu: " + str(height2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '15Z-'
task4imagecreate2epu ['HEIGHT'] = height2epu
# ---------------------------------------------------------------------------------------------
# (16) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 1 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 1 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 1 # ONE DIRECTIONS IN 2D
message2print = "{(Step 16A/70) trying" + "; rowpitch2epu-trying-by-create2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 16B/70) set" + "; rowpitch2epu-set-by-create2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; rowpitch2epu-failed-by-create2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '16Z-'
task4imagecreate2epu ['ROWPITCH'] = rowpitch2epu
# ---------------------------------------------------------------------------------------------
# (17) POINTER - REQUIRED
# ---------------------------------------------------------------------------------------------
pointer2epu = None
size2epu = int(width2epu * height2epu) # CALCULATED MEMORY
if size2epu == 0:
size2epu = 4400 # MINIMUM MEMORY
message2print = "{(Step 17A/70) trying" + "; pointer2epu-trying-by-create2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
arena2epu = Arena4Xi(size2epu) # SYSTEM RESERVER MEMORY FOR IMAGE
message2print = "{(Step 17B1/70) got" + "; arena2epu-got-by-create2image4epu: " + str(arena2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
size2arena = arena2epu.size #
message2print = "{(Step 17B2/70) got" + "; size2arena-got-by-create2buffer4epu: " + str(size2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 640000
buffer2arena = arena2epu.buffer
message2print = "{(Step 17B3/70) got" + "; buffer2arena-got-by-create2buffer4epu: " + str(buffer2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17B-'
if size2arena < size2epu:
size2epu = size2arena # AVAILABLE MEMORY FOR IMAGE
message2print = "{(Step 17C/70) set" + "; size2epu-set-by-create2buffer4epu to: " + str(size2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17C-'
else:
pass
pointer2epu = buffer2arena
message2print = "{(Step 17D/70) set" + "; pointer2epu-set-by-create2buffer4epu to: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17D-'
except:
message2print = "{(Step 17Z/70) failed" + "; pointer2epu-failed-by-create2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '17Z-'
task4imagecreate2epu ['POINTER'] = pointer2epu
task4imagecreate2epu ['SIZE'] = size2epu # EXTRA
# ---------------------------------------------------------------------------------------------
# (18) FORMAT - REQUIRED
# ---------------------------------------------------------------------------------------------
format2epu = {}
message2print = "{(Step 18A/70) trying" + "; format2epu-trying-by-create2image4epu: " + str(format2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
format2epu['ORDER'] = 'CL_RGBA'
message2print = "{(Step 18B/70) set" + "; format2epu-set-by-create2image4epu to: " + str(format2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'ORDER': 'CL_RGBA'}
code2ack = code2ack + '18B-'
format2epu['TYPE'] = 'CL_UNORM_INT8'
message2print = "{(Step 18C/70) set" + "; format2epu-set-by-create2image4epu to: " + str(format2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
code2ack = code2ack + '18C-'
except:
message2print = "{(Step 18Z/70) failed" + "; format2epu-failed-by-create2image4epu: " + str(format2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '18Z-'
task4imagecreate2epu ['FORMAT'] = format2epu
# ---------------------------------------------------------------------------------------------
# (19) DEPTH - MUST BE 0
# ---------------------------------------------------------------------------------------------
depth2epu = 0
message2print = "{(Step 19A/70) set" + "; depth2epu-set-by-create2image4epu to: " + str(depth2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '19A-'
task4imagecreate2epu ['DEPTH'] = depth2epu
else:
pass # PARAMETER DATA RECEIVED
except:
message2print = "{(Step 1Z1/70) yielded" + "; task4imagecreate2epu-yielded-by-create2image4epu: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '1Z1-'
# ---------------------------------------------------------------------------------------------
# TASK EITHER GENERATED BY THIS PROGRAM (NONE GIVEN) OR GIVEN BY USER
# ---------------------------------------------------------------------------------------------
keys2task = task4imagecreate2epu.keys()
message2print = "{(Step 19A/70) using" + "; keys2task-using-by-create2image4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFER',
# 'CODE2ERROR',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'FLAGS',
# 'FORMAT',
# 'FUNCTION2CALLBACK',
# 'HEIGHT',
# 'PIPE',
# 'PLATFORM',
# 'POINTER',
# 'QUEUE',
# 'ROWPITCH',
# 'SIZE',
# 'WIDTH']; time: 00:53:55 10/05/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (Step 20A/70) - CREATE 2D IMAGE FOR EPU!
# ---------------------------------------------------------------------------------------------
epu2image4xi = {}
message2print = "{(Step 20A/70) initialized" + "; epu2image4xi-initialized-by-create2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
message2print = "{(Step 21A0/70) try" + "; data2callback-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 21A/70) - DATA2CALLBACK - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['DATA2CALLBACK'] = task4imagecreate2epu['DATA2CALLBACK']
message2print = "{(Step 21A1/70) initialized" + "; data2callback-created-by-create2image4epu to: " + str(epu2image4xi['DATA2CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 05:56:13 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'}; time: 05:56:13 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '21A1-'
except:
message2print = "{(Step 21Z1/70) yielded" + "; data2callback-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '21Z1-'
message2print = "{(Step 22B0/70) try" + "; function2callback-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 22B/70) - FUNCTION2CALLBACK - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['FUNCTION2CALLBACK'] = task4imagecreate2epu['FUNCTION2CALLBACK']
message2print = "{(Step 22B1/70) initialized" + "; function2callback-created-by-create2image4epu to: " + str(epu2image4xi['FUNCTION2CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B1-'
except:
message2print = "{(Step 22Z2/70) yielded" + "; function2callback-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z2-'
message2print = "{(Step 22C0/70) try" + "; platform-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 22C/70) - PLATFORM - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['PLATFORM'] = task4imagecreate2epu['PLATFORM']
message2print = "{(Step 22C1/70) initialized" + "; platform-created-by-create2image4epu to: " + str(epu2image4xi['PLATFORM']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}; time: 05:56:13 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '22C1-'
except:
message2print = "{(Step 22Z3/70) yielded" + "; platform-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z3-'
message2print = "{(Step 23A/70) try" + "; context2epu-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 23/70) - CONTEXT - REQUIRED
# -----------------------------------------------------------------------------------------
epu2image4xi['CONTEXT'] = task4imagecreate2epu['CONTEXT']
message2print = "{(Step 23B/70) initialized" + "; context-created-by-create2image4epu to: " + str(epu2image4xi['CONTEXT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 05:56:12 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None}; time: 05:56:13 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z1/70) yielded" + "; context-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z1-'
message2print = "{(Step 24A/70) try" + "; device-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 24/70) - DEVICE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['DEVICE'] = task4imagecreate2epu['DEVICE']
message2print = "{(Step 24B/70) initialized" + "; device-created-by-create2image4epu to: " + str(epu2image4xi['DEVICE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2,
# 'MAX2UNITS4COMPUTE': 4,
# 'SIZE2MEMORY4GLOBAL': 3221225472,
# 'NATIVE2WIDTHFLOAT4VECTOR': 4,
# 'MAX2SIZE4WORKGROUP': 1024,
# 'PREFERRED2WIDTHCHAR4VECTOR': 16,
# 'SIZE2CACHE': 65536,
# 'IEEE754-2008FUSED2MULTIPLY-ADD': 'NACK',
# 'TYPE4CACHE': 'Read/Write',
# 'PREFERRED2WIDTHINT4VECTOR': 4,
# 'SIZE2PREFERREDWORKGROUPMULTIPLE4KERNEL': 1,
# 'NATIVE2WIDTHINT4VECTOR': 4,
# 'SIZE2BUFFER4CONSTANT': 65536,
# 'EXECUTE2FUNCTION4NATIVE': 'ACK',
# 'PREFERRED2WIDTHDOUBLE4VECTOR': 0,
# 'MAX2NUMBER4CONSTANTARGS': 8,
# 'VERSION2DRIVER': '2.0', 'EXTENSIONS': 'cl_amd_fp64 ...
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z1/70) yielded" + "; device-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z1-'
message2print = "{(Step 25A/70) try" + "; code2error-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 25/70) - ERROR CODE - REQUIRED
# -----------------------------------------------------------------------------------------
epu2image4xi['CODE2ERROR'] = task4imagecreate2epu['CODE2ERROR']
message2print = "{(Step 25B/70) initialized" + "; code2error-created-by-create2image4epu to: " + str(epu2image4xi['CODE2ERROR']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z1/70) yielded" + "; code2error-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z1-'
message2print = "{(Step 26A/70) try" + "; queue-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 26/70) - QUEUE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['QUEUE'] = task4imagecreate2epu['QUEUE']
message2print = "{(Step 26B/70) initialized" + "; queue-created-by-create2image4epu to: " + str(epu2image4xi['QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z1/70) yielded" + "; queue-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z1-'
message2print = "{(Step 27A/70) try" + "; pipe-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 27/70) - PIPE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['PIPE'] = task4imagecreate2epu['PIPE']
message2print = "{(Step 27B/70) initialized" + "; pipe-created-by-create2image4epu to: " + str(epu2image4xi['PIPE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z1/70) yielded" + "; pipe-epu2image4xi-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z1-'
message2print = "{(Step 28A/70) try" + "; commandqueue-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['COMMANDQUEUE'] = task4imagecreate2epu['COMMANDQUEUE']
message2print = "{(Step 28B/70) initialized" + "; commandqueue-created-by-create2image4epu to: " + str(epu2image4xi['COMMANDQUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 07:13:59 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-8A-9B-10B-9B-10B-11B-12B-13B-14B-15B-16B-17B-18B-',
# 'INFO2PRIVATE': None,
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z1/70) yielded" + "; commandqueue-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '28Z1-'
message2print = "{(Step 29A/70) try" + "; bufferinfo-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (29) BUFFER INFO - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['BUFFER'] = task4imagecreate2epu['BUFFER']
message2print = "{(Step 29B/70) initialized" + "; bufferinfo-created-by-create2image4epu to: " + str(epu2image4xi['BUFFER']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 05:56:12 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ...
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z1/70) yielded" + "; bufferinfo-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z1-'
message2print = "{(Step 30A/70) try" + "; eventinfo-try-by-create2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (30) EVENT INFO - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['EVENT'] = task4imagecreate2epu['EVENT']
message2print = "{(Step 30B/70) initialized" + "; eventinfo-created-by-create2image4epu to: " + str(epu2image4xi['EVENT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4epu-failed ; time: 05:56:12 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2event4epu',
# 'METHOD': 'create2event4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-',
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z1/70) yielded" + "; eventinfo-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '30Z1-'
message2print = "{(Step 31A/70) try" + "; flags-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (31) FLAGS - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['FLAGS'] = task4imagecreate2epu['FLAGS']
message2print = "{(Step 31B/70) initialized" + "; flags-created-by-create2image4epu to: " + str(epu2image4xi['FLAGS']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z1/70) yielded" + "; flags-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z1-'
message2print = "{(Step 34A/70) try" + "; width-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (34) WIDTH - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['WIDTH'] = task4imagecreate2epu['WIDTH']
message2print = "{(Step 34H/70) initialized" + "; width-created-by-create2image4epu to: " + str(epu2image4xi['WIDTH']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '34H-'
except:
message2print = "{(Step 34Z1/70) yielded" + "; width-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z1-'
message2print = "{(Step 35A/70) try" + "; height-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (35) HEIGHT - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['HEIGHT'] = task4imagecreate2epu['HEIGHT']
message2print = "{(Step 35H/70) initialized" + "; height-created-by-create2image4epu to: " + str(epu2image4xi['HEIGHT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '35H-'
except:
message2print = "{(Step 35Z1/70) yielded" + "; height-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '35Z1-'
message2print = "{(Step 36A/70) try" + "; rowpitch-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (36) ROWPITCH - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['ROWPITCH'] = task4imagecreate2epu['ROWPITCH']
message2print = "{(Step 36B/70) initialized" + "; rowpitch-created-by-create2image4epu to: " + str(epu2image4xi['ROWPITCH']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z1/70) yielded" + "; rowpitch-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '36Z1-'
message2print = "{(Step 37A/70) try" + "; pointer-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (37) POINTER - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['POINTER'] = task4imagecreate2epu['POINTER']
message2print = "{(Step 37B/70) initialized" + "; pointer-created-by-create2image4epu to: " + str(epu2image4xi['POINTER']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37B-'
except:
message2print = "{(Step 37Z1/70) yielded" + "; pointer-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '37Z1-'
message2print = "{(Step 38A/70) try" + "; format-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (38) FORMAT - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['FORMAT'] = task4imagecreate2epu['FORMAT']
message2print = "{(Step 38B/70) initialized" + "; format-created-by-create2image4epu to: " + str(epu2image4xi['FORMAT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
code2ack = code2ack + '38B-'
except:
message2print = "{(Step 38Z1/70) yielded" + "; format-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '38Z1-'
message2print = "{(Step 39A/70) try" + "; depth-try-by-create2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (39) DEPTH - MUST BE 0
# ---------------------------------------------------------------------------------------------
epu2image4xi['DEPTH'] = task4imagecreate2epu['DEPTH']
message2print = "{(Step 39B/70) initialized" + "; depth-created-by-create2image4epu to: " + str(epu2image4xi['DEPTH']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '39B-'
except:
message2print = "{(Step 39Z1/70) yielded" + "; depth-yielded-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '39Z1-'
# -----------------------------------------------------------------------------------------
# (Step 70/70)
# -----------------------------------------------------------------------------------------
epu2image4xi ['ACK2RETURN'] = code2ack
epu2image4xi ['NACK2RETURN'] = code2nack
message2print = "{(Step 70/70) returning" + "; epu2image4xi-returning-by-create2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# 'DEPTH'
# 'WIDTH'
# 'HEIGHT'
return epu2image4xi
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def set2image4epu(task4imageset2epu=None):
'''
sets 2D images for EPU
'''
global epu2image4xi
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "set2image4epu"
method2print = "set2image4epu"
message2print = "{(Step 1A/33) started" + "; set2image4epu-started: " + str(set2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4imageset2epu-to-set2image4epu: " + str(task4imageset2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'QUEUE': ,
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 07:13:59 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'COMMANDQUEUE': {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 07:13:59 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-8A-9B-10B-9B-10B-11B-12B-13B-14B-15B-16B-17B-18B-',
# 'INFO2PRIVATE': None,
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 07:13:59 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'],
# 'ack2return': ' 2C-2E-2F-2G-',
# 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'DEVICE': {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROPERTIES': None,
# 'PIPE': (, )},
# 'DEVICE': {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2, 'MAX2UNITS4COMPUTE': 4, 'SIZE2MEMORY4GLOBAL': 3221225472, 'NATIVE2WIDTHFLOAT4VECTOR': 4, 'MAX2SIZE4WORKGROUP': 1024, 'PREFERRED2WIDTHCHAR4VECTOR': 16, 'SIZE2CACHE': 65536,
# 'IEEE754-2008FUSED2MULTIPLY-ADD': 'NACK', 'TYPE4CACHE': 'Read/Write', 'PREFERRED2WIDTHINT4VECTOR': 4, 'SIZE2PREFERREDWORKGROUPMULTIPLE4KERNEL': 1, 'NATIVE2WIDTHINT4VECTOR': 4,
# 'SIZE2BUFFER4CONSTANT': 65536, 'EXECUTE2FUNCTION4NATIVE': 'ACK', 'PREFERRED2WIDTHDOUBLE4VECTOR': 0, 'MAX2NUMBER4CONSTANTARGS': 8, 'VERSION2DRIVER': '2.0',
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) set" + "; epu2image4xi-set-by-set2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-set2image4epu: " + str(create2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ;
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-set2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z/70) yielded" + "; epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
# ---------------------------------------------------------------------------------------------
# SET
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 22A0/70) try" + "; data2callback-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 21A/70) - DATA2CALLBACK - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['DATA2CALLBACK'] = task4imageset2epu['DATA2CALLBACK']
message2print = "{(Step 21A1/70) set" + "; data2callback-set-by-set2image4epu to: " + str(epu2image4xi['DATA2CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21A1-'
except:
message2print = "{(Step 21Z1/70) yielded" + "; data2callback-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '21Z1-'
message2print = "{(Step 22B0/70) try" + "; function2callback-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 22B/70) - FUNCTION2CALLBACK - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['FUNCTION2CALLBACK'] = task4imageset2epu['FUNCTION2CALLBACK']
message2print = "{(Step 22B1/70) set" + "; function2callback-set-by-set2image4epu to: " + str(epu2image4xi['FUNCTION2CALLBACK']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B1-'
except:
message2print = "{(Step 22Z2/70) yielded" + "; function2callback-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '22Z2-'
message2print = "{(Step 22C0/70) try" + "; platform2callback-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
# -----------------------------------------------------------------------------------------
# (Step 22C/70) - PLATFORM - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['PLATFORM'] = task4imageset2epu['PLATFORM']
message2print = "{(Step 2C1/70) set" + "; platform-set-by-set2image4epu to: " + str(epu2image4xi['PLATFORM']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2ack = code2ack + '2C1-'
except:
message2print = "{(Step 22Z3/70) yielded" + "; platform-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z3-'
message2print = "{(Step 23A/70) try" + "; context2epu-try-by-set2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 23/70) - CONTEXT - REQUIRED
# -----------------------------------------------------------------------------------------
epu2image4xi['CONTEXT'] = task4imageset2epu['CONTEXT']
message2print = "{(Step 23B/70) set" + "; context-set-by-set2image4epu to: " + str(epu2image4xi['CONTEXT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 07:13:59 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}, 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None}; time: 07:13:59 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z1/70) yielded" + "; context-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z1-'
message2print = "{(Step 24A/70) try" + "; device-try-by-set2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 24/70) - DEVICE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['DEVICE'] = task4imageset2epu['DEVICE']
message2print = "{(Step 24B/70) set" + "; device-set-by-set2image4epu to: " + str(epu2image4xi['DEVICE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2,
# 'MAX2UNITS4COMPUTE': 4,
# 'SIZE2MEMORY4GLOBAL': 3221225472,
# 'NATIVE2WIDTHFLOAT4VECTOR': 4,
# 'MAX2SIZE4WORKGROUP': 1024,
# 'PREFERRED2WIDTHCHAR4VECTOR': 16,
# 'SIZE2CACHE': 65536,
# 'IEEE754-2008FUSED2MULTIPLY-ADD': 'NACK',
# 'TYPE4CACHE': 'Read/Write',
# 'PREFERRED2WIDTHINT4VECTOR': 4,
# 'SIZE2PREFERREDWORKGROUPMULTIPLE4KERNEL': 1,
# 'NATIVE2WIDTHINT4VECTOR': 4,
# 'SIZE2BUFFER4CONSTANT': 65536,
# 'EXECUTE2FUNCTION4NATIVE': 'ACK',
# 'PREFERRED2WIDTHDOUBLE4VECTOR': 0,
# 'MAX2NUMBER4CONSTANTARGS': 8,
# 'VERSION2DRIVER': '2.0',
# 'EXTENSIONS': 'cl_amd_fp64 cl_khr_global_int32_base_atomics ...
# 'AVAILABLE2COMPILER': 'ACK',
# 'MAX2DIMENSIONS4WORKITEMS': 3,
# 'SUPPORT2CORRECTION4ERROR': 0,
# 'BITS2ADDRESS': 64,
# 'AVAILABLE': 'ACK',
# 'SIZE2MEMORY4LOCAL': 32768,
# 'VENDOR': 'AuthenticAMD',
# 'SUPPORT2IMAGE': 'NACK',
# 'MAX2SIZE4KERNELARGUMENT': 4096,
# 'ACK2RETURN': ' 1C-1D-1E-1F-1D-2A-3A-4A-5A-6A-7A-8A-9A-10A-11A-...
# 'OUT-OF-ORDER2QUEUE': 'NACK',
# 'ALIGNMENT2ADDRESS4BASE': 1024,
# 'PROFILE': 'FULL_PROFILE',
# 'TYPE2MEMORY4LOCAL': 'Global',
# 'PREFERRED2WIDTHFLOAT4VECTOR': 4,
# 'PREFERRED2WIDTHLONG4VECTOR': 2,
# 'MAX2FREQUENCY4CLOCK': 3210,
# 'PREFERRED2WIDTHSHORT4VECTOR': 8,
# 'ID': 4033,
# 'MAX2WORKITEM2': 1024,
# 'NATIVE2WIDTHDOUBLE4VECTOR': 0,
# 'ROUND2ZERO': 'ACK',
# 'NAME': 'AMD64 Family 16 Model 4 Stepping 2, AuthenticAMD',
# 'MAX2WORKITEM1': 1024,
# 'MAX2WORKITEM0': 1024,
# 'SIZE2LINE4CACHE': 64,
# 'MAX2ALLOCATION4MEMORY': 1073741824,
# 'NATIVE2WIDTHCHAR4VECTOR': 16,
# 'QUIET2NANS': 'ACK',
# 'NATIVE2WIDTHSHORT4VECTOR': 8,
# 'ROUND2NEAREST4EVEN': 'ACK',
# 'VERSION': 'OpenCL 1.1 ATI-Stream-v2.3 (451)',
# 'NACK2RETURN': ' ',
# 'MEMORY2UNIFIED4HOSTANDDEVICE': 1,
# 'ENDIANESS2DEVICE': 'Little',
# 'MINIMUM2ALIGNMENT4DATATYPE': 128,
# 'ROUND2+VE3INFINITY': 'ACK',
# 'TYPE': 'CL_DEVICE_TYPE_EPU',
# 'DENORMS2SINGLEPRECISION4FLOATINGPOINTCAPABILITY': 'ACK'}; time: 07:13:59 09/06/11 Pacific Daylight Time}
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z1/70) yielded" + "; device-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z1-'
message2print = "{(Step 25A/70) try" + "; code2error-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 25/70) - ERROR CODE - REQUIRED
# -----------------------------------------------------------------------------------------
epu2image4xi['CODE2ERROR'] = task4imageset2epu['CODE2ERROR']
message2print = "{(Step 25B/70) set" + "; code2error-set-by-set2image4epu to: " + str(epu2image4xi['CODE2ERROR']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z1/70) yielded" + "; code2error-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z1-'
message2print = "{(Step 26A/70) try" + "; queue-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 26/70) - QUEUE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['QUEUE'] = task4imageset2epu['QUEUE']
message2print = "{(Step 26B/70) set" + "; queue-set-by-set2image4epu to: " + str(epu2image4xi['QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z1/70) yielded" + "; queue-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z1-'
message2print = "{(Step 27A/70) try" + "; pipe-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# -----------------------------------------------------------------------------------------
# (Step 27/70) - PIPE - EXTRA
# -----------------------------------------------------------------------------------------
epu2image4xi['PIPE'] = task4imageset2epu['PIPE']
message2print = "{(Step 27B/70) set" + "; pipe-set-by-set2image4epu to: " + str(epu2image4xi['PIPE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z1/70) yielded" + "; pipe-epu2image4xi-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z1-'
message2print = "{(Step 28A/70) try" + "; commandqueue-try-by-set2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['COMMANDQUEUE'] = task4imageset2epu['COMMANDQUEUE']
message2print = "{(Step 28B/70) set" + "; commandqueue-set-by-set2image4epu to: " + str(epu2image4xi['COMMANDQUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z1/70) yielded" + "; commandqueue-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z1-'
message2print = "{(Step 29A/70) try" + "; bufferinfo-try-by-set2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (29) BUFFER INFO - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['BUFFER'] = task4imageset2epu['BUFFER']
message2print = "{(Step 29B/70) set" + "; bufferinfo-set-by-set2image4epu to: " + str(epu2image4xi['BUFFER']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z1/70) yielded" + "; bufferinfo-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '29Z1-'
message2print = "{(Step 30A/70) try" + "; eventinfo-try-by-set2image4epu: {}" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (30) EVENT INFO - EXTRA
# ---------------------------------------------------------------------------------------------
epu2image4xi['EVENT'] = task4imageset2epu['EVENT']
message2print = "{(Step 30B/70) set" + "; eventinfo-set-by-set2image4epu to: " + str(epu2image4xi['EVENT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z1/70) yielded" + "; eventinfo-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '30Z1-'
message2print = "{(Step 31A/70) try" + "; flags-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (31) FLAGS - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['FLAGS'] = task4imageset2epu['FLAGS']
message2print = "{(Step 31B/70) set" + "; flags-set-by-set2image4epu to: " + str(epu2image4xi['FLAGS']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z1/70) yielded" + "; flags-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '31Z1-'
message2print = "{(Step 34A/70) try" + "; width-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (34) WIDTH - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['WIDTH'] = task4imageset2epu['WIDTH']
message2print = "{(Step 34H/70) set" + "; width-set-by-set2image4epu to: " + str(epu2image4xi['WIDTH']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34H-'
except:
message2print = "{(Step 34Z1/70) yielded" + "; width-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z1-'
message2print = "{(Step 35A/70) try" + "; height-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (35) HEIGHT - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['HEIGHT'] = task4imageset2epu['HEIGHT']
message2print = "{(Step 35H/70) set" + "; height-set-by-set2image4epu to: " + str(epu2image4xi['HEIGHT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '35H-'
except:
message2print = "{(Step 35Z1/70) yielded" + "; height-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '35Z1-'
message2print = "{(Step 36A/70) try" + "; rowpitch-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (36) ROWPITCH - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['ROWPITCH'] = task4imageset2epu['ROWPITCH']
message2print = "{(Step 36B/70) set" + "; rowpitch-set-by-set2image4epu to: " + str(epu2image4xi['ROWPITCH']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z1/70) yielded" + "; rowpitch-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '36Z1-'
message2print = "{(Step 37A/70) try" + "; pointer-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (37) POINTER - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['POINTER'] = task4imageset2epu['POINTER']
message2print = "{(Step 37B/70) set" + "; pointer-set-by-set2image4epu to: " + str(epu2image4xi['POINTER']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37B-'
except:
message2print = "{(Step 37Z1/70) yielded" + "; pointer-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '37Z1-'
message2print = "{(Step 38A/70) try" + "; format-try-by-set2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ---------------------------------------------------------------------------------------------
# (38) FORMAT - REQUIRED
# ---------------------------------------------------------------------------------------------
epu2image4xi['FORMAT'] = task4imageset2epu['FORMAT']
message2print = "{(Step 38B/70) set" + "; format-set-by-set2image4epu to: " + str(epu2image4xi['FORMAT']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '38B-'
except:
message2print = "{(Step 38Z1/70) yielded" + "; format-yielded-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# yielded
code2nack = code2nack + '38Z1-'
# -----------------------------------------------------------------------------------------
# (Step 70/70)
# -----------------------------------------------------------------------------------------
epu2image4xi ['ACK2RETURN'] = code2ack
epu2image4xi ['NACK2RETURN'] = code2nack
message2print = "{(Step 70/70) returning" + "; epu2image4xi-returning-by-set2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'ACK2RETURN': ' 23B-24B-25B-26B-27B-28B-', 'ROWPITCH': 800, 'DATA2CALLBACK': ...
return epu2image4xi
#
# -------------------------------------------------------------------------------------------------
#copy2copy4epu"
# channel2copypublish4epu = response4copy2image['PUBLISHERCHANNEL']
# channel2copypublish4epu.send(message2copyimagesend4epu)
# print("(Step 17B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copypublish4epu, " MESSAGE2SEND4EPU: " , message2copyimagesend4epu)
# except:
# print('(Step 17Z1/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------------
# # (18) LET MANOEUVRE2IMAGE4EPU TO RECEIVE COPY AND AND SEND ROGER VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print("(Step 18C/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2copyimage4epu(queue2copy4epu, channel2copyconsume4epu, channel2copypublish4epu)
# print("(Step 18D/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2copyimage4epu)
# except:
# print("(Step 18Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
# # -----------------------------------------------------------------------------------------------
# # (19) RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 19A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# try:
# channel2copyconsume4epu = response4copy2image['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copyconsume4epu.recv()
# print("(Step 19B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# # roger2copy4epu
# except:
# print('(Step 19Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------------
# # (20) SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2IMAGE4EPU TO RECEIVE
# # -----------------------------------------------------------------------------------------------
# print('(Step 20A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# try:
# message2copyimagesend4epu = "copy2copy4epu"
# channel2copypublish4epu = response4copy2image['PUBLISHERCHANNEL']
# channel2copypublish4epu.send(message2copyimagesend4epu)
# print("(Step 20B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copypublish4epu, " MESSAGE2SEND4EPU: " , message2copyimagesend4epu)
# # copy2copy4epu
# except:
# print('(Step 20Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------------
# # (21) LET MANOEUVRE2IMAGE4EPU TO RECEIVE READY AND TO SEND READY
# # -----------------------------------------------------------------------------------------------
# print("(Step 21A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2copyimage4epu(queue2copy4epu, channel2copyconsume4epu, channel2copypublish4epu)
# print("(Step 21B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2copyimage4epu)
# except:
# print("(Step 21Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (22) RECEIVE CONTROL & COMMAND READY VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 22A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# try:
# channel2copyconsume4epu = response4copy2image['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copyconsume4epu.recv()
# print("(Step 22B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# # copy2copy4epu
# except:
# print('(Step 22Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGE4EPU ', time4xi())
# # ----------------------------------------------------------------------------------------------
# # (24) PUT IMAGE PATH TO QUEUE
# # ----------------------------------------------------------------------------------------------
# print("(Step 24A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue2copy4dragon.put(path2dragon)
# print("(Step 24B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# # ..//..//..//..//..//web//images//png//dragonxi.png
# except:
# print("(Step 24Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (25) LET MANOEUVRE2IMAGE4EPU TO GET FROM QUEUE AND TO SEND EITHER ACK OR NACK VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print("(Step 25A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2copyimage4epu(queue2copy4epu, channel2copyconsume4epu, channel2copypublish4epu)
# print("(Step 25B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2copyimage4epu)
# except:
# print("(Step 25Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (26) RECEIVE ACK OR NACK ABOUT IMAGE OPERATION VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 26A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2copyimagereceive4epu = channel2copyconsume4epu.recv()
# print("(Step 26D/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# # ack2imageinfo4epu
# except:
# print('(Step 26Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# # -----------------------------------------------------------------------------------------------
# (27) LET MANOEUVRE2IMAGE4EPU GO TO STATE 0
# # -----------------------------------------------------------------------------------------------
# print("(Step 27A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2copyimage4epu(queue2copy4epu, channel2copyconsume4epu, channel2copypublish4epu)
# print("(Step 27B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvre4epu)
# except:
# print("(Step 27Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
#">
# -------------------------------------------------------------------------------------------------
def copy2image4epu(task4imagecopy2epu=None):
'''
copies 2D images for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global control2copyimage4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "copy2image4epu"
method2print = "copy2image4epu"
message2print = "{(Step 0A/33) started" + "; copy2image4epu-started: " + str(copy2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0B/33) passed" + "; task4imagecopy2epu-to-copy2image4epu: " + str(task4imagecopy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 0C/70) created" + "; epu2image4xi-created-by-copy2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 0D/70) skipped" + "; create2image4epu-skipped-by-copy2image4epu: " + str(copy2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 0E/70) set" + "; epu2image4xi-set-by-copy2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 0Z/70) yielded" + "; epu2image4xi-yielded-by-copy2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '0Z-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - CHECK PARAMETERS
# -----------------------------------------------------------------------------------------
try:
if task4imagecopy2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR COPY - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4imagecopy2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4imagecopy2epu-created-by-copy2image4epu to: " + str(task4imagecopy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-copy2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-copy2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; copy2image4epu-failed ; time: 07:01:44 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2image4epu',
# 'METHOD': 'copy2image4epu'}; time: 07:01:44 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagecopy2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagecopy2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4imagecopy2epu-created-by-copy2image4epu to: " + str(task4imagecopy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; copy2image4epu-failed ; time: 07:01:44 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2image4epu',
# 'METHOD': 'copy2image4epu'}}; time: 07:01:44 10/04/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-copy2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-copy2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}; time: 07:01:44 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-copy2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4imagecopy2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) ...
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4imagecopy2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', ...
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4imagecopy2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE SOURCE OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
imagesourceinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imagesourceinfo2epu-trying-by-copy2image4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imagesourceinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imagesourceinfo2epu-got-by-copy2image4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imagesourceinfo2epu-failed-by-copy2image4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4imagecopy2epu ['IMAGESOURCE'] = imagesourceinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) IMAGE DESTINATION OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
imagedestinationinfo2epu = {}
message2print = "{(Step 6A/70) trying" + "; imagedestinationinfo2epu-trying-by-copy2image4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imagedestinationinfo2epu = get2imageinfo4epu()
message2print = "{(Step 6B/70) got" + "; imagedestinationinfo2epu-got-by-copy2image4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
# note: source and destination will be the same !
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; imagedestinationinfo2epu-failed-by-copy2image4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4imagecopy2epu ['IMAGEDESTINATION'] = imagedestinationinfo2epu
# ---------------------------------------------------------------------------------------------
# (7) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 7A/70) trying" + "; queue2epu-trying-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 7B/70) got" + "; queue2epu-got-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; queue2epu-failed-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4imagecopy2epu ['QUEUE'] = queue2epu
# ---------------------------------------------------------------------------------------------
# (8) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 8A/70) trying" + "; pipe2epu-trying-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 8B/70) got" + "; pipe2epu-got-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; pipe2epu-failed-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4imagecopy2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (9) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; commandqueueinfo2epu-got-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 07:01:44 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4imagecopy2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (10) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 10A/70) trying" + "; bufferinfo2epu-trying-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 10B/70) got" + "; bufferinfo2epu-got-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE' ...
code2ack = code2ack + '10B-'
except:
message2print = "{(Step 10Z/70) failed" + "; bufferinfo2epu-failed-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '10Z-'
task4imagecopy2epu ['BUFFER'] = bufferinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventinfo2epu-trying-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 11B/70) got" + "; eventinfo2epu-got-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4epu-failed ; time: 07:01:44 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2event4epu',
# 'METHOD': 'create2event4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-',
# 'QUEUE': ,
# 'NACK2RETURN': ' ',
# 'CONTEXT': {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventinfo2epu-failed-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4imagecopy2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 12A/70) trying" + "; eventwaitlist2epu-trying-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 12B/70) set" + "; eventwaitlist2epu-set-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4imagecopy2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (13) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 13A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 13B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4imagecopy2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (14) ORIGIN FOR SOURCE - REQUIRED
# ---------------------------------------------------------------------------------------------
origin4source2epu = {}
message2print = "{(Step 14A/70) trying" + "; origin4source2epu-trying-by-copy2image4epu: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin4source2epu['X'] = 0
origin4source2epu['Y'] = 0
origin4source2epu['Z'] = 0
message2print = "{(Step 14B/70) set" + "; origin4source2epu-set-by-copy2image4epu to: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; origin4source2epu-failed-by-copy2image4epu: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4imagecopy2epu ['SOURCEORIGIN'] = origin4source2epu
# ---------------------------------------------------------------------------------------------
# (15) ORIGIN FOR DESTINATION - REQUIRED
# ---------------------------------------------------------------------------------------------
origin4destination2epu = {}
message2print = "{(Step 15A/70) trying" + "; origin4destination2epu-trying-by-copy2image4epu: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin4destination2epu['X'] = 100
origin4destination2epu['Y'] = 100
origin4destination2epu['Z'] = 100
message2print = "{(Step 15B/70) set" + "; origin4destination2epu-set-by-copy2image4epu to: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; origin4destination2epu-failed-by-copy2image4epu: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '15Z-'
task4imagecopy2epu ['DESTINATIONORIGIN'] = origin4destination2epu
# --------------------------------------------------------------------------------------------------------
# (16) REGION - REGION OF A IMAGE TO BE COPIED
# --------------------------------------------------------------------------------------------------------
region4copy2epu = {}
message2print = "{(Step 16A/70) trying" + "; region4copy2epu-trying-by-copy2image4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region4copy2epu['X'] = 10
region4copy2epu['Y'] = 10
region4copy2epu['Z'] = 10
message2print = "{(Step 16B/70) set" + "; region4copy2epu-set-by-copy2image4epu to: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; region4copy2epu-failed-by-copy2image4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '16Z-'
task4imagecopy2epu ['REGION'] = region4copy2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
else:
pass
# ---------------------------------------------------------------------------------------------
# CHECK PARAMETERS - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4imagecopy2epu.keys()
message2print = "{(Step 20/70) using" + "; keys2task-using-by-copy2image4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DESTINATIONORIGIN',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGEDESTINATION',
# 'IMAGESOURCE',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'SOURCEORIGIN']; time: 01:21:58 10/05/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-copy2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-copy2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagecopy2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagecopy2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4imagecopy2epu-created-by-copy2image4epu to: " + str(task4imagecopy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-copy2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-copy2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-copy2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4imagecopy2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-copy2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4imagecopy2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-copy2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4imagecopy2epu ['DEVICE'] = device2epu
if 'IMAGESOURCE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) SOURCE IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
sourceimageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; sourceimageinfo2epu-trying-by-copy2image4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
sourceimageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; sourceimageinfo2epu-got-by-copy2image4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; sourceimageinfo2epu-failed-by-copy2image4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4imagecopy2epu ['IMAGESOURCE'] = sourceimageinfo2epu
if 'IMAGEDESTINATION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) DESTINATION IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
destinationimageinfo2epu = {}
message2print = "{(Step 26A/70) trying" + "; destinationimageinfo2epu-trying-by-copy2image4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
destinationimageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 26B/70) got" + "; destinationimageinfo2epu-got-by-copy2image4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; destinationimageinfo2epu-failed-by-copy2image4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4imagecopy2epu ['IMAGEDESTINATION'] = destinationimageinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 27A/70) trying" + "; queue2epu-trying-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 27B/70) got" + "; queue2epu-got-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; queue2epu-failed-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4imagecopy2epu ['QUEUE'] = queue2epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 28A/70) trying" + "; pipe2epu-trying-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 28B/70) got" + "; pipe2epu-got-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; pipe2epu-failed-by-copy2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4imagecopy2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; commandqueueinfo2epu-got-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4imagecopy2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'BUFFER' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (30) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 30A/70) trying" + "; bufferinfo2epu-trying-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 30B/70) got" + "; bufferinfo2epu-got-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z/70) failed" + "; bufferinfo2epu-failed-by-copy2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '30Z-'
task4imagecopy2epu ['BUFFER'] = bufferinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventinfo2epu-trying-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 31B/70) got" + "; eventinfo2epu-got-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventinfo2epu-failed-by-copy2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4imagecopy2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 32A/70) trying" + "; eventwaitlist2epu-trying-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 32B/70) set" + "; eventwaitlist2epu-set-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4imagecopy2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 33A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 33B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4imagecopy2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'SOURCEORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) SOURCEORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
source4origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; source4origin2epu-trying-by-copy2image4epu: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
source4origin2epu['X'] = 0
source4origin2epu['Y'] = 0
source4origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; source4origin2epu-set-by-copy2image4epu to: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; source4origin2epu-failed-by-copy2image4epu: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4imagecopy2epu ['SOURCEORIGIN'] = source4origin2epu
if 'DESTINATIONORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (35) DESTINATIONORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
destination4origin2epu = {}
message2print = "{(Step 35A/70) trying" + "; destination4origin2epu-trying-by-copy2image4epu: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
destination4origin2epu['X'] = 100
destination4origin2epu['Y'] = 100
destination4origin2epu['Z'] = 100
message2print = "{(Step 35B/70) set" + "; destination4origin2epu-set-by-copy2image4epu to: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '35B-'
except:
message2print = "{(Step 35Z/70) failed" + "; destination4origin2epu-failed-by-copy2image4epu: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '35Z-'
task4imagecopy2epu ['DESTINATIONSOURCEORIGIN'] = destination4origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 36A/70) trying" + "; region2epu-trying-by-copy2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO WRITE
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO WRITE
region2epu['Z'] = 0 # DEPTH IN PIXELS TO WRITE
message2print = "{(Step 36B/70) set" + "; region2epu-set-by-copy2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; region2epu-failed-by-copy2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '36Z-'
task4imagecopy2epu ['REGION'] = region2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER CHECKING AND PROVIDING FOR MISSING ONES
# ---------------------------------------------------------------------------------------------
keys2task = task4imagecopy2epu.keys()
message2print = "{(Step 39/70) set" + "; keys2task-set-by-copy2image4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DESTINATIONORIGIN',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGEDESTINATION',
# 'IMAGESOURCE',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'SOURCEORIGIN']; time: 01:28:44 10/05/11 Pacific Daylight Time}
except:
message2print = "{(Step 39Z/70) yielded" + "; task4imagecopy2epu-yielded-by-copy2image4epu: " + str(task4imagecopy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '39Z-'
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2copyimage4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-copy2image4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
#
consumerchannel2epu, publisherchannel2epu = task4imagecopy2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2epu-got-by-copy2image4epu: " + str(consumerchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2epu-got-by-copy2image4epu: " + str(publisherchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2copyimage4epu['CONSUMERCHANNEL'] = consumerchannel2epu
control2copyimage4epu['PUBLISHERCHANNEL'] = publisherchannel2epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2epu = False
queue2epu = None
message2print = "{(Step 41A/70) trying" + "queue2epu-trying-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = task4imagecopy2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2epu-got-by-copy2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2epu = True
control2copyimage4epu['QUEUE'] = queue2epu
code2ack = code2ack + '41C-'
except:
ack4queue2epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-copy2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2copyimage4epu, # in this module to handle queue and pipe channels
# args =(queue2epu, # caller puts and gets - does NOT call any functions
# consumerchannel2epu, publisherchannel2epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-copy2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-copy2image4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-13B-14B-15B-16B-40D-41C-
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-copy2image4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70C/70) returning" + "; control2copyimage4epu-returning-by-copy2image4epu: " + str(control2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return control2copyimage4epu
#
# -------------------------------------------------------------------------------------------------
#copy2copyimagetobuffer4epu"
# channel2copyimagetobufferpublish4epu = response4copy2imagetobuffer['PUBLISHERCHANNEL']
# channel2copyimagetobufferpublish4epu.send(message2copyimagetobuffersend4epu)
# print("(Step 61B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copyimagetobufferpublish4epu, " MESSAGE2SEND4EPU: " , message2copyimagetobuffersend4epu)
# except:
# print('(Step 61Z1/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# # ------------------------------------------------------------------------------------------
# # (62) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE COPY AND AND SEND ROGER VIA PIPE
# # ------------------------------------------------------------------------------------------
# print("(Step 62A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copyimagetobuffer4epu(queue2copyimagetobuffer4epu, channel2copyimagetobufferconsume4epu, channel2copyimagetobufferpublish4epu)
# print("(Step 62B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copyimagetobuffer4epu)
# except:
# print("(Step 62Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# else:
# pass # trust activated thread
# # ---------------------------------------------------------------------------------------------
# # (63) RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------
# print('(Step 63A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# try:
# channel2copyimagetobufferconsume4epu = response4copy2imagetobuffer['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copyimagetobufferconsume4epu.recv()
# print("(Step 63B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyimagetobufferconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# #
# except:
# print('(Step 63Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# # ---------------------------------------------------------------------------------------------------
# # (64) SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE
# # ---------------------------------------------------------------------------------------------------
# print('(Step 64A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# try:
# message2copyimagetobuffersend4epu = "copy2copyimagetobuffer4epu"
# channel2copyimagetobufferpublish4epu = response4copy2imagetobuffer['PUBLISHERCHANNEL']
# channel2copyimagetobufferpublish4epu.send(message2copyimagetobuffersend4epu)
# print("(Step 64B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copyimagetobufferpublish4epu, " MESSAGE2SEND4EPU: " , message2copyimagetobuffersend4epu)
# #
# except:
# print('(Step 64Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# # -----------------------------------------------------------------------------------
# # (65) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE READY AND TO SEND READY
# # -----------------------------------------------------------------------------------
# print("(Step 65A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copyimagetobuffer4epu(queue2copyimagetobuffer4epu, channel2copyimagetobufferconsume4epu, channel2copyimagetobufferpublish4epu)
# print("(Step 65B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copyimagetobuffer4epu)
# except:
# print("(Step 65Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# # ---------------------------------------------------------------------------------------
# # (66) RECEIVE CONTROL & COMMAND READY VIA PIPE
# # ---------------------------------------------------------------------------------------
# print('(Step 66A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# try:
# channel2copyimagetobufferconsume4epu = response4copy2imagetobuffer['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copyimagetobufferconsume4epu.recv()
# print("(Step 66B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyimagetobufferconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# #
# except:
# print('(Step 66Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY2IMAGETOBUFFER4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------
# # (67) PUT IMAGE PATH TO QUEUE
# # -----------------------------------------------------------------------------------------
# print("(Step 67A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue2copyimagetobuffer4dragon.put(path2dragon)
# print("(Step 67B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# # ..//..//..//..//..//web//images//png//dragonxi.png
# except:
# print("(Step 67Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# # ------------------------------------------------------------------------------------------------------
# # (68) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO GET FROM QUEUE AND TO SEND EITHER ACK OR NACK VIA PIPE
# # -------------------------------------------------------------------------------------------------------
# print("(Step 68A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copyimagetobuffer4epu(queue2copyimagetobuffer4epu, channel2copyimagetobufferconsume4epu, channel2copyimagetobufferpublish4epu)
# print("(Step 68B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copyimagetobuffer4epu)
# except:
# print("(Step 68Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (69) RECEIVE ACK OR NACK ABOUT IMAGE OPERATION VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 69A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2copyimagereceive4epu = channel2copyimagetobufferconsume4epu.recv()
# print("(Step 69D/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copyimagetobufferconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# except:
# print('(Step 69Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# # -------------------------------------------------------------------------------------------------------
# # (70) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU GO TO STATE 0
# # -------------------------------------------------------------------------------------------------------
# print("(Step 70A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copyimagetobuffer4epu(queue2copyimagetobuffer4epu, channel2copyimagetobufferconsume4epu, channel2copyimagetobufferpublish4epu)
# print("(Step 70B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvreimagecopytobuffer4epu)
# except:
# print("(Step 70Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
#">
# -------------------------------------------------------------------------------------------------
def copy2imagetobuffer4epu(task4copyimagetobuffer2epu=None):
'''
copies 2D images to buffer for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global epu2buffer4xi # BUFFER FOR EPU
global control2copyimagetobuffer4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "copy2imagetobuffer4epu"
method2print = "copy2imagetobuffer4epu"
message2print = "{(Step 1A/33) started" + "; copy2imagetobuffer4epu-started: " + str(copy2imagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1B/33) passed" + "; task4copyimagetobuffer2epu-to-copy2imagetobuffer4epu: " + str(task4copyimagetobuffer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) created" + "; epu2image4xi-created-by-copy2imagetobuffer4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-copy2imagetobuffer4epu: " + str(copy2imagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# create2image4epu-skipped-by-copy2imagetobuffer4epu
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-copy2imagetobuffer4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z1/70) yielded" + "; epu2image4xi-yielded-by-copy2imagetobuffer4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z1-'
# -----------------------------------------------------------------------------------------
# CREATE EPU2BUFFER4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2buffer4xi is None:
epu2buffer4xi = create2buffer4epu() # INITIALIZE BUFFER FOR EPU
message2print = "{(Step 1F/70) created" + "; epu2buffer4xi-created-by-copy2imagetobuffer4epu to: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1G/70) skipped" + "; create2buffer4epu-skipped-by-copy2imagetobuffer4epu: " + str(copy2imagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
try:
epu2buffer4xi = create2buffer4epu()
message2print = "{(Step 1H/70) set" + "; epu2buffer4xi-set-by-copy2imagetobuffer4epu to: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': ...
except:
epu2buffer4xi = {}
message2print = "{(Step 1Z2/70) yielded" + "; epu2buffer4xi-yielded-by-copy2imagetobuffer4epu: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z2-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - ANALYZE TASK
# -----------------------------------------------------------------------------------------
if task4copyimagetobuffer2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR COPY - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4copyimagetobuffer2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4copyimagetobuffer2epu-created-by-copy2imagetobuffer4epu to: " + str(task4copyimagetobuffer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-copy2imagetobuffer4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2imagetobuffer4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2imagetobuffer4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2imagetobuffer4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-copy2imagetobuffer4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; copy2imagetobuffer4epu-failed; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2imagetobuffer4epu',
# 'METHOD': 'copy2imagetobuffer4epu'}; time: 03:40:47 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4copyimagetobuffer2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4copyimagetobuffer2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4copyimagetobuffer2epu-created-by-copy2imagetobuffer4epu to: " + str(task4copyimagetobuffer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; copy2imagetobuffer4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2imagetobuffer4epu',
# 'METHOD': 'copy2imagetobuffer4epu'}}; time: 03:40:47 10/04/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-copy2imagetobuffer4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-copy2imagetobuffer4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}; time: 03:40:47 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-copy2imagetobuffer4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4copyimagetobuffer2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'],'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None}; time: 03:40:47 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4copyimagetobuffer2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2,
# 'MAX2UNITS4COMPUTE': 4,
# 'SIZE2MEMORY4GLOBAL': 3221225472,
# 'NATIVE2WIDTHFLOAT4VECTOR': 4,
# 'MAX2SIZE4WORKGROUP': 1024,
# 'PREFERRED2WIDTHCHAR4VECTOR': 16,
# 'SIZE2CACHE': 65536,
# 'IEEE754-2008FUSED2MULTIPLY-ADD': 'NACK',
# 'TYPE4CACHE': 'Read/Write',
# 'PREFERRED2WIDTHINT4VECTOR': 4,
# 'SIZE2PREFERREDWORKGROUPMULTIPLE4KERNEL': 1,
# 'NATIVE2WIDTHINT4VECTOR': 4,
# 'SIZE2BUFFER4CONSTANT': 65536,
# 'EXECUTE2FUNCTION4NATIVE': 'ACK',
# 'PREFERRED2WIDTHDOUBLE4VECTOR': 0,
# 'MAX2NUMBER4CONSTANTARGS': 8,
# 'VERSION2DRIVER': '2.0',
# 'EXTENSIONS': 'cl_amd_fp64 ...
# 'AVAILABLE2COMPILER': 'ACK',
# 'MAX2DIMENSIONS4WORKITEMS': 3,
# 'SUPPORT2CORRECTION4ERROR': 0,
# 'BITS2ADDRESS': 64,
# 'AVAILABLE': 'ACK',
# 'SIZE2MEMORY4LOCAL': 32768,
# 'VENDOR': 'AuthenticAMD',
# 'SUPPORT2IMAGE': 'NACK',
# 'MAX2SIZE4KERNELARGUMENT': 4096,
# 'ACK2RETURN': ' 1C-1D-1E-1F-1D-2A-...
# 'OUT-OF-ORDER2QUEUE': 'NACK',
# 'ALIGNMENT2ADDRESS4BASE': 1024,
# 'PROFILE': 'FULL_PROFILE',
# 'TYPE2MEMORY4LOCAL': 'Global',
# 'PREFERRED2WIDTHFLOAT4VECTOR': 4,
# 'PREFERRED2WIDTHLONG4VECTOR': 2,
# 'MAX2FREQUENCY4CLOCK': 3210,
# 'PREFERRED2WIDTHSHORT4VECTOR': 8,
# 'ID': 4033,
# 'MAX2WORKITEM2': 1024,
# 'NATIVE2WIDTHDOUBLE4VECTOR': 0,
# 'ROUND2ZERO': 'ACK',
# 'NAME': 'AMD64 Family 16 Model 4 Stepping 2,
# AuthenticAMD',
# 'MAX2WORKITEM1': 1024,
# 'MAX2WORKITEM0': 1024,
# 'SIZE2LINE4CACHE': 64,
# 'MAX2ALLOCATION4MEMORY': 1073741824,
# 'NATIVE2WIDTHCHAR4VECTOR': 16,
# 'QUIET2NANS': 'ACK',
# 'NATIVE2WIDTHSHORT4VECTOR': 8,
# 'ROUND2NEAREST4EVEN': 'ACK',
# 'VERSION': 'OpenCL 1.1 ATI-Stream-v2.3 (451)',
# 'NACK2RETURN': ' ',
# 'MEMORY2UNIFIED4HOSTANDDEVICE': 1,
# 'ENDIANESS2DEVICE': 'Little',
# 'MINIMUM2ALIGNMENT4DATATYPE': 128,
# 'ROUND2+VE3INFINITY': 'ACK',
# 'TYPE': 'CL_DEVICE_TYPE_EPU',
# 'DENORMS2SINGLEPRECISION4FLOATINGPOINTCAPABILITY': 'ACK'}; time: 03:40:47 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4copyimagetobuffer2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE SOURCE OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
imagesourceinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imagesourceinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imagesourceinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imagesourceinfo2epu-got-by-copy2imagetobuffer4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': ...
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imagesourceinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(imagesourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4copyimagetobuffer2epu ['IMAGESOURCE'] = imagesourceinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) BUFFER DESTINATION OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
bufferdestinationinfo2epu = {}
message2print = "{(Step 6A/70) trying" + "; bufferdestinationinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(bufferdestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferdestinationinfo2epu = get2bufferinfo4epu()
message2print = "{(Step 6B/70) got" + "; bufferdestinationinfo2epu-got-by-copy2imagetobuffer4epu: " + str(bufferdestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; bufferdestinationinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(bufferdestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4copyimagetobuffer2epu ['BUFFERDESTINATION'] = bufferdestinationinfo2epu
# ---------------------------------------------------------------------------------------------
# (7) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2copyimagetobuffer4epu = None
message2print = "{(Step 7A/70) trying" + "; queue2copyimagetobuffer4epu-trying-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copyimagetobuffer4epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 7B/70) got" + "; queue2copyimagetobuffer4epu-got-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; queue2copyimagetobuffer4epu-failed-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4copyimagetobuffer2epu ['QUEUE'] = queue2copyimagetobuffer4epu
# ---------------------------------------------------------------------------------------------
# (8) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 8A/70) trying" + "; pipe2epu-trying-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 8B/70) got" + "; pipe2epu-got-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; pipe2epu-failed-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4copyimagetobuffer2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (9) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; commandqueueinfo2epu-got-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4copyimagetobuffer2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 11B/70) got" + "; eventinfo2epu-got-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4epu-failed ; time: 03:40:47 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2event4epu',
# 'METHOD': 'create2event4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 1D-1E-...
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4copyimagetobuffer2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 12A/70) trying" + "; eventwaitlist2epu-trying-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 12B/70) set" + "; eventwaitlist2epu-set-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4copyimagetobuffer2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (13) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 13A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 13B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4copyimagetobuffer2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (14) ORIGIN FOR SOURCE - REQUIRED
# ---------------------------------------------------------------------------------------------
origin4source2epu = {}
message2print = "{(Step 14A/70) trying" + "; origin4source2epu-trying-by-copy2imagetobuffer4epu: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin4source2epu['X'] = 0
origin4source2epu['Y'] = 0
origin4source2epu['Z'] = 0
message2print = "{(Step 14B/70) set" + "; origin4source2epu-set-by-copy2imagetobuffer4epu to: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 0, 'X': 0, 'Z': 0}
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; origin4source2epu-failed-by-copy2imagetobuffer4epu: " + str(origin4source2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4copyimagetobuffer2epu ['SOURCEORIGIN'] = origin4source2epu
# --------------------------------------------------------------------------------------------------------
# (16) REGION - REGION OF A IMAGE TO BE COPIED
# --------------------------------------------------------------------------------------------------------
region4copy2epu = {}
message2print = "{(Step 16A/70) trying" + "; region4copy2epu-trying-by-copy2imagetobuffer4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region4copy2epu['X'] = 10
region4copy2epu['Y'] = 10
region4copy2epu['Z'] = 10
message2print = "{(Step 16B/70) set" + "; region4copy2epu-set-by-copy2imagetobuffer4epu to: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 10, 'X': 10, 'Z': 10}
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; region4copy2epu-failed-by-copy2imagetobuffer4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '16Z-'
task4copyimagetobuffer2epu ['REGION'] = region4copy2epu
# --------------------------------------------------------------------------------------------------------
# (17) OFFSET - WHERE TO BEGIN COPYING DATA INTO DESTINATION BUFFER
# --------------------------------------------------------------------------------------------------------
offset4copy2epu = 0
message2print = "{(Step 17A/70) set" + "; offset4copy2epu-set-by-copy2imagetobuffer4epu to: " + str(offset4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '17A-'
task4copyimagetobuffer2epu ['OFFSET'] = offset4copy2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
else:
pass
# ---------------------------------------------------------------------------------------------
# ANALYZE TASK - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4copyimagetobuffer2epu.keys()
message2print = "{(Step 20/70) got" + "; keys2task-got-by-copy2imagetobuffer4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFERDESTINATION',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGESOURCE',
# 'OFFSET',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'SOURCEORIGIN']; time: 01:28:44 10/05/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-copy2imagetobuffer4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2imagetobuffer4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2imagetobuffer4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2imagetobuffer4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-copy2imagetobuffer4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4copyimagetobuffer2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4copyimagetobuffer2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4copyimagetobuffer2epu-created-by-copy2imagetobuffer4epu to: " + str(task4copyimagetobuffer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-copy2imagetobuffer4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-copy2imagetobuffer4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-copy2imagetobuffer4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4copyimagetobuffer2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-copy2imagetobuffer4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4copyimagetobuffer2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-copy2imagetobuffer4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4copyimagetobuffer2epu ['DEVICE'] = device2epu
if 'IMAGESOURCE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) SOURCE IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
sourceimageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; sourceimageinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
sourceimageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; sourceimageinfo2epu-got-by-copy2imagetobuffer4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; sourceimageinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(sourceimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4copyimagetobuffer2epu ['IMAGESOURCE'] = sourceimageinfo2epu
if 'BUFFERDESTINATION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) DESTINATION BUFFER - REQUIRED
# ---------------------------------------------------------------------------------------------
destinationbufferinfo2epu = {}
message2print = "{(Step 26A/70) trying" + "; destinationbufferinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(destinationbufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
destinationbufferinfo2epu = get2bufferinfo4epu()
message2print = "{(Step 26B/70) got" + "; destinationbufferinfo2epu-got-by-copy2imagetobuffer4epu: " + str(destinationbufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; destinationbufferinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(destinationbufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4copyimagetobuffer2epu ['BUFFERDESTINATION'] = destinationbufferinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2copyimagetobuffer4epu = None
message2print = "{(Step 27A/70) trying" + "; queue2copyimagetobuffer4epu-trying-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copyimagetobuffer4epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 27B/70) got" + "; queue2copyimagetobuffer4epu-got-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; queue2copyimagetobuffer4epu-failed-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4copyimagetobuffer2epu ['QUEUE'] = queue2copyimagetobuffer4epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 28A/70) trying" + "; pipe2epu-trying-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 28B/70) got" + "; pipe2epu-got-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; pipe2epu-failed-by-copy2imagetobuffer4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4copyimagetobuffer2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; commandqueueinfo2epu-got-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4copyimagetobuffer2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventinfo2epu-trying-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 31B/70) got" + "; eventinfo2epu-got-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventinfo2epu-failed-by-copy2imagetobuffer4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4copyimagetobuffer2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 32A/70) trying" + "; eventwaitlist2epu-trying-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 32B/70) set" + "; eventwaitlist2epu-set-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2imagetobuffer4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4copyimagetobuffer2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 33A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 33B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2imagetobuffer4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4copyimagetobuffer2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'SOURCEORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) SOURCEORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
source4origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; source4origin2epu-trying-by-copy2imagetobuffer4epu: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
source4origin2epu['X'] = 0
source4origin2epu['Y'] = 0
source4origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; source4origin2epu-set-by-copy2imagetobuffer4epu to: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; source4origin2epu-failed-by-copy2imagetobuffer4epu: " + str(source4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4copyimagetobuffer2epu ['SOURCEORIGIN'] = source4origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 36A/70) trying" + "; region2epu-trying-by-copy2imagetobuffer4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO WRITE
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO WRITE
region2epu['Z'] = 0 # DEPTH IN PIXELS TO WRITE
message2print = "{(Step 36B/70) set" + "; region2epu-set-by-copy2imagetobuffer4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; region2epu-failed-by-copy2imagetobuffer4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '36Z-'
task4copyimagetobuffer2epu ['REGION'] = region2epu
if 'OFFSET' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (37) OFFSET - WHERE TO BEGIN COPYING DATA INTO DESTINATION BUFFER - REQUIRED
# ---------------------------------------------------------------------------------------------
offset2epu = 0
message2print = "{(Step 37A/70) set" + "; offset2epu-set-by-copy2imagetobuffer4epu to: " + str(offset2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
task4copyimagetobuffer2epu ['OFFSET'] = offset2epu
code2ack = code2ack + '37A-'
# ---------------------------------------------------------------------------------------------
# EOF TASK
# ---------------------------------------------------------------------------------------------
keys2task = task4copyimagetobuffer2epu.keys()
message2print = "{(Step 39/70) set" + "; keys2task-set-by-copy2imagetobuffer4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFERDESTINATION',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGESOURCE',
# 'OFFSET',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'SOURCEORIGIN']; time: 01:28:44 10/05/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2copyimagetobuffer4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-copy2imagetobuffer4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
#
consumerchannel2copyimagetobuffer4epu, publisherchannel2copyimagetobuffer4epu = task4copyimagetobuffer2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2copyimagetobuffer4epu-got-by-copy2imagetobuffer4epu: " + str(consumerchannel2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2copyimagetobuffer4epu-got-by-copy2imagetobuffer4epu: " + str(publisherchannel2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2copyimagetobuffer4epu['CONSUMERCHANNEL'] = consumerchannel2copyimagetobuffer4epu
control2copyimagetobuffer4epu['PUBLISHERCHANNEL'] = publisherchannel2copyimagetobuffer4epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2copyimagetobuffer4epu = False
queue2copyimagetobuffer4epu = None
message2print = "{(Step 41A/70) trying" + "queue2copyimagetobuffer4epu-trying-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copyimagetobuffer4epu = task4copyimagetobuffer2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2copyimagetobuffer4epu-got-by-copy2imagetobuffer4epu: " + str(queue2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2copyimagetobuffer4epu = True
control2copyimagetobuffer4epu['QUEUE'] = queue2copyimagetobuffer4epu
code2ack = code2ack + '41C-'
except:
ack4queue2copyimagetobuffer4epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-copy2imagetobuffer4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2copyimagetobuffer4epu, # in this module to handle queue and pipe channels
# args =(queue2copyimagetobuffer4epu, # caller puts and gets - does NOT call any functions
# consumerchannel2copyimagetobuffer4epu, publisherchannel2copyimagetobuffer4epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-copy2imagetobuffer4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-copy2imagetobuffer4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-11B-12B-13B-14B-16B-17A-40D-41C-
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-copy2imagetobuffer4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70C/70) returning" + "; control2copyimagetobuffer4epu-returning-by-copy2imagetobuffer4epu: " + str(control2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return control2copyimagetobuffer4epu
#
# -------------------------------------------------------------------------------------------------
#copy2copybuffertoimage4epu"
# channel2copybuffertoimagepublish4epu = response4copy2buffertoimage['PUBLISHERCHANNEL']
# channel2copybuffertoimagepublish4epu.send(message2copybuffertoimagesend4epu)
# print("(Step 81B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copybuffertoimagepublish4epu, " MESSAGE2SEND4EPU: " , message2copybuffertoimagesend4epu)
# except:
# print('(Step 81Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# # ------------------------------------------------------------------------------------------
# # (82) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE COPY AND AND SEND ROGER VIA PIPE
# # ------------------------------------------------------------------------------------------
# print("(Step 82C/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copybuffertoimage4epu(queue2copybuffertoimage4epu, channel2copybuffertoimageconsume4epu, channel2copybuffertoimagepublish4epu)
# print("(Step 82D/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copybuffertoimage4epu)
# except:
# print("(Step 82Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# else:
# pass # trust activated thread
# # ---------------------------------------------------------------------------------------------
# # (83) RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------
# print('(Step 83A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# try:
# channel2copybuffertoimageconsume4epu = response4copy2buffertoimage['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copybuffertoimageconsume4epu.recv()
# print("(Step 83B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copybuffertoimageconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# #
# except:
# print('(Step 83Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# # ---------------------------------------------------------------------------------------------------
# # (84) SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE
# # ---------------------------------------------------------------------------------------------------
# print('(Step 84A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# try:
# message2copybuffertoimagesend4epu = "copy2copybuffertoimage4epu"
# channel2copybuffertoimagepublish4epu = response4copy2buffertoimage['PUBLISHERCHANNEL']
# channel2copybuffertoimagepublish4epu.send(message2copybuffertoimagesend4epu)
# print("(Step 84B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2copybuffertoimagepublish4epu, " MESSAGE2SEND4EPU: " , message2copybuffertoimagesend4epu)
# #
# except:
# print('(Step 84Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------
# # (85) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO RECEIVE READY AND TO SEND READY
# # -----------------------------------------------------------------------------------
# print("(Step 85A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copybuffertoimage4epu(queue2copybuffertoimage4epu, channel2copybuffertoimageconsume4epu, channel2copybuffertoimagepublish4epu)
# print("(Step 85B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copybuffertoimage4epu)
# except:
# print("(Step 85Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# # ---------------------------------------------------------------------------------------
# # (86) RECEIVE CONTROL & COMMAND READY VIA PIPE
# # ---------------------------------------------------------------------------------------
# print('(Step 86A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# try:
# channel2copybuffertoimageconsume4epu = response4copy2buffertoimage['CONSUMERCHANNEL']
# message2copyimagereceive4epu = channel2copybuffertoimageconsume4epu.recv()
# print("(Step 86B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copybuffertoimageconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# #
# except:
# print('(Step 86Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPYBUFFERTOIMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------
# # (87) PUT IMAGE PATH TO QUEUE
# # -----------------------------------------------------------------------------------------
# print("(Step 87A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue2copybuffertoimage4dragon.put(path2dragon)
# print("(Step 87B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# # ..//..//..//..//..//web//images//png//dragonxi.png
# except:
# print("(Step 87Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# # ------------------------------------------------------------------------------------------------------
# # (88) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU TO GET FROM QUEUE AND TO SEND EITHER ACK OR NACK VIA PIPE
# # -------------------------------------------------------------------------------------------------------
# print("(Step 88A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copybuffertoimage4epu(queue2copybuffertoimage4epu, channel2copybuffertoimageconsume4epu, channel2copybuffertoimagepublish4epu)
# print("(Step 88B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", manoeuvre2copybuffertoimage4epu)
# except:
# print("(Step 88Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (89) RECEIVE ACK OR NACK ABOUT IMAGE OPERATION VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 89A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2copyimagereceive4epu = channel2copybuffertoimageconsume4epu.recv()
# print("(Step 89D/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2copybuffertoimageconsume4epu, " CONTROL & COMMAND: ", message2copyimagereceive4epu)
# except:
# print('(Step 89Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# # -------------------------------------------------------------------------------------------------------
# # (90) LET MANOEUVRE2COPYIMAGETOBUFFER4EPU GO TO STATE 0
# # -------------------------------------------------------------------------------------------------------
# print("(Step 90A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
# try:
# response2manoeuvreimagecopytobuffer4epu = manoeuvre2copybuffertoimage4epu(queue2copybuffertoimage4epu, channel2copybuffertoimageconsume4epu, channel2copybuffertoimagepublish4epu)
# print("(Step 90B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvreimagecopytobuffer4epu)
# except:
# print("(Step 90Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGETOBUFFER4EPU ", time4xi())
#">
# -------------------------------------------------------------------------------------------------
def copy2buffertoimage4epu(task4copybuffertoimage2epu=None):
'''
copies buffer to image for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global epu2buffer4xi # BUFFER FOR EPU
global control2copybuffertoimage4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "copy2buffertoimage4epu"
method2print = "copy2buffertoimage4epu"
message2print = "{(Step 1A/33) started" + "; copy2buffertoimage4epu-started: " + str(copy2buffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1B/33) passed" + "; task4copybuffertoimage2epu-to-copy2buffertoimage4epu: " + str(task4copybuffertoimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) created" + "; epu2image4xi-created-by-copy2buffertoimage4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-copy2buffertoimage4epu: " + str(copy2buffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# skipped
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-copy2buffertoimage4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z1/70) yielded" + "; epu2image4xi-yielded-by-copy2buffertoimage4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z1-'
# -----------------------------------------------------------------------------------------
# CREATE EPU2BUFFER4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2buffer4xi is None:
epu2buffer4xi = create2buffer4epu() # INITIALIZE BUFFER FOR EPU
message2print = "{(Step 1F/70) created" + "; epu2buffer4xi-created-by-copy2buffertoimage4epu to: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1G/70) skipped" + "; create2buffer4epu-skipped-by-copy2buffertoimage4epu: " + str(copy2buffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# skipped
except:
try:
epu2buffer4xi = create2buffer4epu()
message2print = "{(Step 1H/70) set" + "; epu2buffer4xi-set-by-copy2buffertoimage4epu to: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2buffer4xi = {}
message2print = "{(Step 1Z2/70) yielded" + "; epu2buffer4xi-yielded-by-copy2buffertoimage4epu: " + str(epu2buffer4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z2-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - ANALYZE TASKS
# -----------------------------------------------------------------------------------------
if task4copybuffertoimage2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR COPY - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4copybuffertoimage2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4copybuffertoimage2epu-created-by-copy2buffertoimage4epu to: " + str(task4copybuffertoimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-copy2buffertoimage4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2buffertoimage4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2buffertoimage4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2buffertoimage4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-copy2buffertoimage4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; copy2buffertoimage4epu-failed ; time: 04:41:15 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2buffertoimage4epu',
# 'METHOD': 'copy2buffertoimage4epu'}; time: 04:41:15 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4copybuffertoimage2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4copybuffertoimage2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4copybuffertoimage2epu-created-by-copy2buffertoimage4epu to: " + str(task4copybuffertoimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; copy2buffertoimage4epu-failed ; time: 04:41:15 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'copy2buffertoimage4epu',
# 'METHOD': 'copy2buffertoimage4epu'}}; time: 04:41:15 10/04/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-copy2buffertoimage4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-copy2buffertoimage4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'],
# 'ack2return': ' 2C-2E-2F-2G-',
# 'nack2return': ' ',
# 'available2platform': 1,
# 'max2entries': 1}; time: 04:41:15 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-copy2buffertoimage4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4copybuffertoimage2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4copybuffertoimage2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2,
# 'MAX2UNITS4COMPUTE': 4,
# 'SIZE2MEMORY4GLOBAL': 3221225472, ...
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4copybuffertoimage2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE DESTINATION OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
imagedestinationinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imagedestinationinfo2epu-trying-by-copy2buffertoimage4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imagedestinationinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imagedestinationinfo2epu-got-by-copy2buffertoimage4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 04:41:15 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'],'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'PIPE': (, ),
# 'COUNT2REFERENCE': 1,
# 'FUNCTION2CALLBACK': ,
# 'COMMANDQUEUE': ...
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imagedestinationinfo2epu-failed-by-copy2buffertoimage4epu: " + str(imagedestinationinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4copybuffertoimage2epu ['IMAGEDESTINATION'] = imagedestinationinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) BUFFER SOURCE OBJECT - REQUIRED
# ---------------------------------------------------------------------------------------------
buffersourceinfo2epu = {}
message2print = "{(Step 6A/70) trying" + "; buffersourceinfo2epu-trying-by-copy2buffertoimage4epu: " + str(buffersourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
buffersourceinfo2epu = get2bufferinfo4epu()
message2print = "{(Step 6B/70) got" + "; buffersourceinfo2epu-got-by-copy2buffertoimage4epu: " + str(buffersourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 04:41:15 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': ...
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; buffersourceinfo2epu-failed-by-copy2buffertoimage4epu: " + str(buffersourceinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4copybuffertoimage2epu ['BUFFERSOURCE'] = buffersourceinfo2epu
# ---------------------------------------------------------------------------------------------
# (7) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2copybuffertoimage4epu = None
message2print = "{(Step 7A/70) trying" + "; queue2copybuffertoimage4epu-trying-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copybuffertoimage4epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 7B/70) got" + "; queue2copybuffertoimage4epu-got-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; queue2copybuffertoimage4epu-failed-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4copybuffertoimage2epu ['QUEUE'] = queue2copybuffertoimage4epu
# ---------------------------------------------------------------------------------------------
# (8) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 8A/70) trying" + "; pipe2epu-trying-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 8B/70) got" + "; pipe2epu-got-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; pipe2epu-failed-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4copybuffertoimage2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (9) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; commandqueueinfo2epu-got-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4copybuffertoimage2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventinfo2epu-trying-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 11B/70) got" + "; eventinfo2epu-got-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'DATA2CALLBACK': ...
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventinfo2epu-failed-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4copybuffertoimage2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 12A/70) trying" + "; eventwaitlist2epu-trying-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 12B/70) set" + "; eventwaitlist2epu-set-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4copybuffertoimage2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (13) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 13A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 13B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4copybuffertoimage2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (15) ORIGIN FOR DESTINATION - REQUIRED
# ---------------------------------------------------------------------------------------------
origin4destination2epu = {}
message2print = "{(Step 15A/70) trying" + "; origin4destination2epu-trying-by-copy2buffertoimage4epu: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin4destination2epu['X'] = 100
origin4destination2epu['Y'] = 100
origin4destination2epu['Z'] = 100
message2print = "{(Step 15B/70) set" + "; origin4destination2epu-set-by-copy2buffertoimage4epu to: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 100, 'X': 100, 'Z': 100}
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; origin4destination2epu-failed-by-copy2buffertoimage4epu: " + str(origin4destination2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '15Z-'
task4copybuffertoimage2epu ['DESTINATIONORIGIN'] = origin4destination2epu
# --------------------------------------------------------------------------------------------------------
# (16) REGION - REGION OF A IMAGE TO BE COPIED
# --------------------------------------------------------------------------------------------------------
region4copy2epu = {}
message2print = "{(Step 16A/70) trying" + "; region4copy2epu-trying-by-copy2buffertoimage4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region4copy2epu['X'] = 10
region4copy2epu['Y'] = 10
region4copy2epu['Z'] = 10
message2print = "{(Step 16B/70) set" + "; region4copy2epu-set-by-copy2buffertoimage4epu to: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 10, 'X': 10, 'Z': 10}
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; region4copy2epu-failed-by-copy2buffertoimage4epu: " + str(region4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '16Z-'
task4copybuffertoimage2epu ['REGION'] = region4copy2epu
# --------------------------------------------------------------------------------------------------------
# (17) OFFSET - WHERE TO BEGIN COPYING DATA FROM SOURCE BUFFER
# --------------------------------------------------------------------------------------------------------
offset4copy2epu = 0
message2print = "{(Step 17A/70) set" + "; offset4copy2epu-set-by-copy2buffertoimage4epu to: " + str(offset4copy2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
task4copybuffertoimage2epu ['OFFSET'] = offset4copy2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------
# ANALYZE TASKS - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4copybuffertoimage2epu.keys()
message2print = "{(Step 20/70) got" + "; keys2task-got-by-copy2buffertoimage4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFERSOURCE',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DESTINATIONORIGIN',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGEDESTINATION',
# 'OFFSET',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION']; time: 04:41:15 10/04/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-copy2buffertoimage4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "copy2buffertoimage4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "copy2buffertoimage4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; copy2buffertoimage4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-copy2buffertoimage4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4copybuffertoimage2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4copybuffertoimage2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4copybuffertoimage2epu-created-by-copy2buffertoimage4epu to: " + str(task4copybuffertoimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-copy2buffertoimage4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-copy2buffertoimage4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-copy2buffertoimage4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4copybuffertoimage2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-copy2buffertoimage4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4copybuffertoimage2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-copy2buffertoimage4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4copybuffertoimage2epu ['DEVICE'] = device2epu
if 'IMAGEDESTINATION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) DESTINATION IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
destinationimageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; destinationimageinfo2epu-trying-by-copy2buffertoimage4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
destinationimageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; destinationimageinfo2epu-got-by-copy2buffertoimage4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; destinationimageinfo2epu-failed-by-copy2buffertoimage4epu: " + str(destinationimageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4copybuffertoimage2epu ['IMAGEDESTINATION'] = destinationimageinfo2epu
if 'BUFFERSOURCE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) SOURCE BUFFER - REQUIRED
# ---------------------------------------------------------------------------------------------
sourcebufferinfo2epu = {}
message2print = "{(Step 26A/70) trying" + "; sourcebufferinfo2epu-trying-by-copy2buffertoimage4epu: " + str(sourcebufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
sourcebufferinfo2epu = get2bufferinfo4epu()
message2print = "{(Step 26B/70) got" + "; sourcebufferinfo2epu-got-by-copy2buffertoimage4epu: " + str(sourcebufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; sourcebufferinfo2epu-failed-by-copy2buffertoimage4epu: " + str(sourcebufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4copybuffertoimage2epu ['BUFFERSOURCE'] = sourcebufferinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2copybuffertoimage4epu = None
message2print = "{(Step 27A/70) trying" + "; queue2copybuffertoimage4epu-trying-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copybuffertoimage4epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 27B/70) got" + "; queue2copybuffertoimage4epu-got-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; queue2copybuffertoimage4epu-failed-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4copybuffertoimage2epu ['QUEUE'] = queue2copybuffertoimage4epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 28A/70) trying" + "; pipe2epu-trying-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 28B/70) got" + "; pipe2epu-got-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; pipe2epu-failed-by-copy2buffertoimage4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4copybuffertoimage2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; commandqueueinfo2epu-trying-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; commandqueueinfo2epu-got-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; commandqueueinfo2epu-failed-by-copy2buffertoimage4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4copybuffertoimage2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventinfo2epu-trying-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 31B/70) got" + "; eventinfo2epu-got-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventinfo2epu-failed-by-copy2buffertoimage4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4copybuffertoimage2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 32A/70) trying" + "; eventwaitlist2epu-trying-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 32B/70) set" + "; eventwaitlist2epu-set-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlist2epu-failed-by-copy2buffertoimage4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4copybuffertoimage2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 33A/70) trying" + "; eventwaitlistquantity2epu-trying-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 33B/70) set" + "; eventwaitlistquantity2epu-set-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-copy2buffertoimage4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4copybuffertoimage2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'DESTINATIONORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) DESTINATIONORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
destination4origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; destination4origin2epu-trying-by-copy2buffertoimage4epu: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
destination4origin2epu['X'] = 0
destination4origin2epu['Y'] = 0
destination4origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; destination4origin2epu-set-by-copy2buffertoimage4epu to: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; destination4origin2epu-failed-by-copy2buffertoimage4epu: " + str(destination4origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4copybuffertoimage2epu ['DESTINATIONORIGIN'] = destination4origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 36A/70) trying" + "; region2epu-trying-by-copy2buffertoimage4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO WRITE
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO WRITE
region2epu['Z'] = 0 # DEPTH IN PIXELS TO WRITE
message2print = "{(Step 36B/70) set" + "; region2epu-set-by-copy2buffertoimage4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; region2epu-failed-by-copy2buffertoimage4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '36Z-'
task4copybuffertoimage2epu ['REGION'] = region2epu
if 'OFFSET' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (37) OFFSET - WHERE TO BEGIN COPYING DATA FROM SOURCE BUFFER - REQUIRED
# ---------------------------------------------------------------------------------------------
offset2epu = 0
message2print = "{(Step 37A/70) set" + "; offset2epu-set-by-copy2buffertoimage4epu to: " + str(offset2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
task4copybuffertoimage2epu ['OFFSET'] = offset2epu
code2ack = code2ack + '37A-'
# ---------------------------------------------------------------------------------------------
# EOF TASK ANALYSIS
# ---------------------------------------------------------------------------------------------
keys2task = task4copybuffertoimage2epu.keys()
message2print = "{(Step 39/70) set" + "; keys2task-set-by-copy2buffertoimage4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BUFFERSOURCE',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DESTINATIONORIGIN',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGEDESTINATION',
# 'OFFSET',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION']; time: 04:52:11 10/04/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2copybuffertoimage4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-copy2buffertoimage4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
#
consumerchannel2copybuffertoimage4epu, publisherchannel2copybuffertoimage4epu = task4copybuffertoimage2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2copybuffertoimage4epu-got-by-copy2buffertoimage4epu: " + str(consumerchannel2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2copybuffertoimage4epu-got-by-copy2buffertoimage4epu: " + str(publisherchannel2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2copybuffertoimage4epu['CONSUMERCHANNEL'] = consumerchannel2copybuffertoimage4epu
control2copybuffertoimage4epu['PUBLISHERCHANNEL'] = publisherchannel2copybuffertoimage4epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2copybuffertoimage4epu = False
queue2copybuffertoimage4epu = None
message2print = "{(Step 41A/70) trying" + "queue2copybuffertoimage4epu-trying-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2copybuffertoimage4epu = task4copybuffertoimage2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2copybuffertoimage4epu-got-by-copy2buffertoimage4epu: " + str(queue2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2copybuffertoimage4epu = True
control2copybuffertoimage4epu['QUEUE'] = queue2copybuffertoimage4epu
code2ack = code2ack + '41C-'
except:
ack4queue2copybuffertoimage4epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-copy2buffertoimage4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2copybuffertoimage4epu, # in this module to handle queue and pipe channels
# args =(queue2copybuffertoimage4epu, # caller puts and gets - does NOT call any functions
# consumerchannel2copybuffertoimage4epu, publisherchannel2copybuffertoimage4epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-copy2buffertoimage4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-copy2buffertoimage4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-11B-12B-13B-15B-16B-40D-41C-
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-copy2buffertoimage4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70C/70) returning" + "; control2copybuffertoimage4epu-returning-by-copy2buffertoimage4epu: " + str(control2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 04:52:11 10/04/11 Pacific Daylight Time}
return control2copybuffertoimage4epu
#
# -------------------------------------------------------------------------------------------------
#copy2read4epu"
# channel2readpublish4epu = response4read2image['PUBLISHERCHANNEL']
# channel2readpublish4epu.send(message2readsend4epu)
# print("(Step 17B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2readpublish4epu, " MESSAGE2SEND4EPU: " , message2readsend4epu)
# except:
# print('(Step 17Z1/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # ------------------------------------------------------------------------------------------
# # (18) LET MANOEUVRE2IMAGE4EPU TO RECEIVE COPY AND AND SEND ROGER VIA PIPE
# # ------------------------------------------------------------------------------------------
# print("(Step 18C/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2read4epu, channel2readconsume4epu, channel2readpublish4epu)
# print("(Step 18D/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 18Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
# # ---------------------------------------------------------------------------------------------
# # (19) RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------
# print('(Step 19A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# channel2readconsume4epu = response4read2image['CONSUMERCHANNEL']
# message2readreceive4epu = channel2readconsume4epu.recv()
# print("(Step 19B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2readconsume4epu, " CONTROL & COMMAND: ", message2readreceive4epu)
# # roger2read4epu
# except:
# print('(Step 19Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # ---------------------------------------------------------------------------------------------------
# # (20) SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2IMAGE4EPU TO RECEIVE
# # ---------------------------------------------------------------------------------------------------
# print('(Step 20A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# message2readsend4epu = "ready2read4epu"
# channel2readpublish4epu = response4read2image['PUBLISHERCHANNEL']
# channel2readpublish4epu.send(message2readsend4epu)
# print("(Step 20B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2readpublish4epu, " MESSAGE2SEND4EPU: " , message2readsend4epu)
# # ready2read4epu
# except:
# print('(Step 20Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------
# # (21) LET MANOEUVRE2IMAGE4EPU TO RECEIVE READY AND TO SEND READY
# # -----------------------------------------------------------------------------------
# print("(Step 21A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2read4epu, channel2readconsume4epu, channel2readpublish4epu)
# print("(Step 21B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 21Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # ---------------------------------------------------------------------------------------
# # (22) RECEIVE CONTROL & COMMAND READY VIA PIPE
# # ---------------------------------------------------------------------------------------
# print('(Step 22A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# channel2readconsume4epu = response4read2image['CONSUMERCHANNEL']
# message2readreceive4epu = channel2readconsume4epu.recv()
# print("(Step 22B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2readconsume4epu, " CONTROL & COMMAND: ", message2readreceive4epu)
# # ready2read4epu
# except:
# print('(Step 22Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------
# # (24) PUT IMAGE PATH TO QUEUE
# # -----------------------------------------------------------------------------------------
# print("(Step 24A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue2read4dragon.put(path2dragon)
# print("(Step 24B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# # ..//..//..//..//..//web//images//png//dragonxi.png
# except:
# print("(Step 24Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# # ------------------------------------------------------------------------------------------------------
# # (25) LET MANOEUVRE2IMAGE4EPU TO GET FROM QUEUE AND TO SEND EITHER ACK OR NACK VIA PIPE
# # -------------------------------------------------------------------------------------------------------
# print("(Step 25A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2read4epu, channel2readconsume4epu, channel2readpublish4epu)
# print("(Step 25B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 25Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (26) RECEIVE ACK OR NACK ABOUT IMAGE OPERATION VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 26A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2readreceive4epu = channel2readconsume4epu.recv()
# print("(Step 26D/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2readconsume4epu, " CONTROL & COMMAND: ", message2readreceive4epu)
# # ack2imageinfo4epu
# except:
# print('(Step 26Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# # -------------------------------------------------------------------------------------------------------
# # (27) LET MANOEUVRE2IMAGE4EPU GO TO STATE 0
# # -------------------------------------------------------------------------------------------------------
# print("(Step 27A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2read4epu, channel2readconsume4epu, channel2readpublish4epu)
# print("(Step 27B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvre4epu)
# except:
# print("(Step 27Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
#">
# -------------------------------------------------------------------------------------------------
def read2image4epu(task4imageread2epu=None):
'''
reads 2D images for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global control2readimage4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "read2image4epu"
method2print = "read2image4epu"
message2print = "{(Step 1A/33) started" + "; read2image4epu-started: " + str(read2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4imageread2epu-to-read2image4epu: " + str(task4imageread2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) created" + "; epu2image4xi-created-by-read2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-read2image4epu: " + str(read2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# skipped
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-read2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z/70) yielded" + "; epu2image4xi-yielded-by-read2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - CHECK PARAMETERS
# -----------------------------------------------------------------------------------------
try:
if task4imageread2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR READ - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4imageread2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4imageread2epu-created-by-read2image4epu to: " + str(task4imageread2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-read2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ;
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "read2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "read2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; read2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-read2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; read2image4epu-failed ; time: 05:06:38 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'read2image4epu',
# 'METHOD': 'read2image4epu'}; time: 05:06:38 10/04/11 Pacific Daylight Time}
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imageread2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imageread2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4imageread2epu-created-by-read2image4epu to: " + str(task4imageread2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; read2image4epu-failed ; time: 05:06:38 10/04/11 Pacific Daylight Time}',
# 'CLASS': 'read2image4epu',
# 'METHOD': 'read2image4epu'}}; time: 05:06:38 10/04/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-read2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-read2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-read2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4imageread2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4imageread2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318,
# 'ID2PLATFORM': '0000000001509568',
# 'PROFILING2QUEUE': 'ACK',
# 'EXECUTE2KERNELS4OPENCL': 'ACK',
# 'NATIVE2WIDTHLONG4VECTOR': 2 ...
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4imageread2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imageinfo2epu-trying-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imageinfo2epu-got-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imageinfo2epu-failed-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4imageread2epu ['IMAGE'] = imageinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 6A/70) trying" + "; queue2epu-trying-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 6B/70) got" + "; queue2epu-got-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; queue2epu-failed-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4imageread2epu ['QUEUE'] = queue2epu
# ---------------------------------------------------------------------------------------------
# (7) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 7A/70) trying" + "; pipe2epu-trying-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 7B/70) got" + "; pipe2epu-got-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; pipe2epu-failed-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4imageread2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (8) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 8A/70) trying" + "; commandqueueinfo2epu-trying-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 8B/70) got" + "; commandqueueinfo2epu-got-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; commandqueueinfo2epu-failed-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4imageread2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (9) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; bufferinfo2epu-trying-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; bufferinfo2epu-got-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; bufferinfo2epu-failed-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4imageread2epu ['BUFFER'] = bufferinfo2epu
# ---------------------------------------------------------------------------------------------
# (10) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 10A/70) trying" + "; eventinfo2epu-trying-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 10B/70) got" + "; eventinfo2epu-got-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': ...
code2ack = code2ack + '10B-'
except:
message2print = "{(Step 10Z/70) failed" + "; eventinfo2epu-failed-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '10Z-'
task4imageread2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventwaitlist2epu-trying-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 11B/70) set" + "; eventwaitlist2epu-set-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventwaitlist2epu-failed-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4imageread2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 12A/70) trying" + "; eventwaitlistquantity2epu-trying-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 12B/70) set" + "; eventwaitlistquantity2epu-set-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4imageread2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (13) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 13A/70) trying" + "; blocking2epu-trying-by-read2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the read command is non-blocking
message2print = "{(Step 13B/70) set" + "; blocking2epu-set-by-read2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# CL_FALSE
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; blocking2epu-failed-by-read2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4imageread2epu ['BLOCKING'] = blocking2epu
# ---------------------------------------------------------------------------------------------
# (14) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 14A/70) trying" + "; origin2epu-trying-by-read2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 14B/70) set" + "; origin2epu-set-by-read2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 0, 'X': 0, 'Z': 0}
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; origin2epu-failed-by-read2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4imageread2epu ['ORIGIN'] = origin2epu
# ---------------------------------------------------------------------------------------------
# (15) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 15A/70) trying" + "; region2epu-trying-by-read2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO READ
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO READ
region2epu['Z'] = 0 # DEPTH IN PIXELS TO READ
message2print = "{(Step 15B/70) set" + "; region2epu-set-by-read2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 90, 'X': 160, 'Z': 0}
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; region2epu-failed-by-read2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '15Z-'
task4imageread2epu ['REGION'] = region2epu
# ---------------------------------------------------------------------------------------------
# (16) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 8 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 10 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 8 # ONE DIRECTIONS IN 2D
width2epu = 800
message2print = "{(Step 16A/70) trying" + "; rowpitch2epu-trying-by-read2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 16B/70) set" + "; rowpitch2epu-set-by-read2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 8000
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; rowpitch2epu-failed-by-read2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '16Z-'
task4imageread2epu ['ROWPITCH'] = rowpitch2epu
# ----------------------------------------------------------------------------------------------------
# (17) POINTER - REQUIRED - THE POINTER TO A BUFFER IN HOST MEMORY WHERE IMAGE DATA IS TO BE READ FROM
# ----------------------------------------------------------------------------------------------------
pointer2epu = None
height2epu = 800
size2epu = int(width2epu * height2epu) # CALCULATED MEMORY
if size2epu == 0:
size2epu = 4400 # MINIMUM MEMORY
message2print = "{(Step 17A/70) trying" + "; pointer2epu-trying-by-read2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
arena2epu = Arena4Xi(size2epu) # SYSTEM RESERVER MEMORY FOR IMAGE
message2print = "{(Step 17B/70) got" + "; arena2epu-got-by-read2image4epu: " + str(arena2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
size2arena = arena2epu.size #
message2print = "{(Step 17C/70) got" + "; size2arena-got-by-read2buffer4epu: " + str(size2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 640000
buffer2arena = arena2epu.buffer
message2print = "{(Step 17D/70) got" + "; buffer2arena-got-by-read2buffer4epu: " + str(buffer2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17D-'
if size2arena < size2epu:
size2epu = size2arena # AVAILABLE MEMORY FOR IMAGE
message2print = "{(Step 17E/70) set" + "; size2epu-set-by-read2buffer4epu to: " + str(size2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17E-'
else:
pass
pointer2epu = buffer2arena
message2print = "{(Step 17F/70) set" + "; pointer2epu-set-by-read2buffer4epu to: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17F-'
except:
message2print = "{(Step 17Z/70) failed" + "; pointer2epu-failed-by-read2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '17Z-'
task4imageread2epu ['POINTER'] = pointer2epu
task4imageread2epu ['SIZE'] = size2epu # AUTOMATIC BY EPUXI
# --------------------------------------------------------------------------------------------------------
# (18) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING READ
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 18A/70) trying" + "; slicepitch2epu-trying-by-read2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 18B/70) set" + "; slicepitch2epu-set-by-read2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '18B-'
except:
message2print = "{(Step 18Z/70) failed" + "; slicepitch2epu-failed-by-read2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '18Z-'
task4imageread2epu ['SLICEPITCH'] = slicepitch2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
else:
pass
# ---------------------------------------------------------------------------------------------
# ANALYSE TASKS - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4imageread2epu.keys()
message2print = "{(Step 20/70) got" + "; keys2task-got-by-read2image4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'POINTER',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SIZE',
# 'SLICEPITCH']; time: 05:25:42 10/04/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-read2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "read2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "read2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; read2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-read2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imageread2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imageread2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4imageread2epu-created-by-read2image4epu to: " + str(task4imageread2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-read2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-read2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-read2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4imageread2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-read2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4imageread2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-read2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4imageread2epu ['DEVICE'] = device2epu
if 'IMAGE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; imageinfo2epu-trying-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; imageinfo2epu-got-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; imageinfo2epu-failed-by-read2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4imageread2epu ['IMAGE'] = imageinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 26A/70) trying" + "; queue2epu-trying-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 26B/70) got" + "; queue2epu-got-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; queue2epu-failed-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4imageread2epu ['QUEUE'] = queue2epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 27A/70) trying" + "; pipe2epu-trying-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 27B/70) got" + "; pipe2epu-got-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; pipe2epu-failed-by-read2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4imageread2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 28A/70) trying" + "; commandqueueinfo2epu-trying-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 28B/70) got" + "; commandqueueinfo2epu-got-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; commandqueueinfo2epu-failed-by-read2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4imageread2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'BUFFER' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (29) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; bufferinfo2epu-trying-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; bufferinfo2epu-got-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; bufferinfo2epu-failed-by-read2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4imageread2epu ['BUFFER'] = bufferinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (30) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 30A/70) trying" + "; eventinfo2epu-trying-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 30B/70) got" + "; eventinfo2epu-got-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z/70) failed" + "; eventinfo2epu-failed-by-read2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '30Z-'
task4imageread2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventwaitlist2epu-trying-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 31B/70) set" + "; eventwaitlist2epu-set-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventwaitlist2epu-failed-by-read2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4imageread2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 32A/70) trying" + "; eventwaitlistquantity2epu-trying-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 32B/70) set" + "; eventwaitlistquantity2epu-set-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-read2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4imageread2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'BLOCKING' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 33A/70) trying" + "; blocking2epu-trying-by-read2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the read command is non-blocking
message2print = "{(Step 33B/70) set" + "; blocking2epu-set-by-read2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; blocking2epu-failed-by-read2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4imageread2epu ['BLOCKING'] = blocking2epu
if 'ORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; origin2epu-trying-by-read2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; origin2epu-set-by-read2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; origin2epu-failed-by-read2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4imageread2epu ['ORIGIN'] = origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (35) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 35A/70) trying" + "; region2epu-trying-by-read2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO READ
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO READ
region2epu['Z'] = 0 # DEPTH IN PIXELS TO READ
message2print = "{(Step 35B/70) set" + "; region2epu-set-by-read2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '35B-'
except:
message2print = "{(Step 35Z/70) failed" + "; region2epu-failed-by-read2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '35Z-'
task4imageread2epu ['REGION'] = region2epu
if 'ROWPITCH' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 1 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 1 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 1 # ONE DIRECTIONS IN 2D
message2print = "{(Step 36A/70) trying" + "; rowpitch2epu-trying-by-read2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 36B/70) set" + "; rowpitch2epu-set-by-read2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; rowpitch2epu-failed-by-read2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '36Z-'
task4imageread2epu ['ROWPITCH'] = rowpitch2epu
if 'POINTER' in keys2task:
pass
else:
# ----------------------------------------------------------------------------------------------------
# (37) POINTER - REQUIRED - THE POINTER TO A BUFFER IN HOST MEMORY WHERE IMAGE DATA IS TO BE READ FROM
# ----------------------------------------------------------------------------------------------------
pointer2epu = None
size2epu = int(width2epu * height2epu) # CALCULATED MEMORY
if size2epu == 0:
size2epu = 4400 # MINIMUM MEMORY
message2print = "{(Step 37A/70) trying" + "; pointer2epu-trying-by-read2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
arena2epu = Arena4Xi(size2epu) # SYSTEM RESERVER MEMORY FOR IMAGE
message2print = "{(Step 37B/70) got" + "; arena2epu-got-by-read2image4epu: " + str(arena2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
size2arena = arena2epu.size #
message2print = "{(Step 37C/70) got" + "; size2arena-got-by-read2buffer4epu: " + str(size2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
buffer2arena = arena2epu.buffer
message2print = "{(Step 37D/70) got" + "; buffer2arena-got-by-read2buffer4epu: " + str(buffer2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37D-'
if size2arena < size2epu:
size2epu = size2arena # AVAILABLE MEMORY FOR IMAGE
message2print = "{(Step 37E/70) set" + "; size2epu-set-by-read2buffer4epu to: " + str(size2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37E-'
else:
pass
pointer2epu = buffer2arena
message2print = "{(Step 37F/70) set" + "; pointer2epu-set-by-read2buffer4epu to: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37F-'
except:
message2print = "{(Step 37Z/70) failed" + "; pointer2epu-failed-by-read2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '37Z-'
task4imageread2epu ['POINTER'] = pointer2epu
task4imageread2epu ['SIZE'] = size2epu # AUTOMATIC BY EPUXI
if 'SLICEPITCH' in keys2task:
pass
else:
# --------------------------------------------------------------------------------------------------------
# (38) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING READ
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 38A/70) trying" + "; slicepitch2epu-trying-by-read2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 38B/70) set" + "; slicepitch2epu-set-by-read2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '38B-'
except:
message2print = "{(Step 38Z/70) failed" + "; slicepitch2epu-failed-by-read2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '38Z-'
task4imageread2epu ['SLICEPITCH'] = slicepitch2epu
# ---------------------------------------------------------------------------------------------
# EOF TASK ANALYSIS
# ---------------------------------------------------------------------------------------------
keys2task = task4imageread2epu.keys()
message2print = "{(Step 39/70) set" + "; keys2task-set-by-read2image4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'POINTER',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SIZE',
# 'SLICEPITCH']; time: 05:25:42 10/04/11 Pacific Daylight Time}
except:
message2print = "{(Step 39Z/70) yielded" + "; task4imageread2epu-yielded-by-read2image4epu: " + str(task4imageread2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '39Z-'
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2readimage4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-read2image4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# (, )
consumerchannel2epu, publisherchannel2epu = task4imageread2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2epu-got-by-read2image4epu: " + str(consumerchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2epu-got-by-read2image4epu: " + str(publisherchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2readimage4epu['CONSUMERCHANNEL'] = consumerchannel2epu
control2readimage4epu['PUBLISHERCHANNEL'] = publisherchannel2epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2epu = False
queue2epu = None
message2print = "{(Step 41A/70) trying" + "; queue2epu-trying-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = task4imageread2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2epu-got-by-read2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2epu = True
control2readimage4epu['QUEUE'] = queue2epu
code2ack = code2ack + '41C-'
except:
ack4queue2epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-read2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2readimage4epu, # in this module to handle queue and pipe channels
# args =(queue2epu, # caller puts and gets - does NOT call any functions
# consumerchannel2epu, publisherchannel2epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-read2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-read2image4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-13B-14B-15B-16B-17D-17F-18B-40D-41C-
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-read2image4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70C/70) returning" + "; control2readimage4epu-returning-by-read2image4epu: " + str(control2readimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
return control2readimage4epu
#
# -------------------------------------------------------------------------------------------------
#copy2mapimage4epu"
# channel4map2imagepublish4epu.send(message2send4epu)
# print("(Step 93B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel4map2imagepublish4epu, " MESSAGE2SEND4EPU: " , message2send4epu)
# except:
# print('(Step 93Z1/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
#
# # ---------------------------------------------------------------------------------------------------------------------
# # SIMULATE MANOEUVRE2COPYIMAGE4EPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------------------------------
# if ack2simulate4epu is True:
# print("(Step 94A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4copy = manoeuvre2mapimage4epu(queue4map2image4epu, channel4map2imageconsume4epu, channel4map2imagepublish4epu)
# print("(Step 94B/700) OF EPU2IMAGE4XI5TEST - PERFORMED MANOEUVRE2COPYIMAGE4EPU, RESPONSE2MANOEUVRE4COPY: ", response2manoeuvre4copy)
# except:
# print("(Step 94Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#
# # ---------------------------------------------------------------------------------------------
# # RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------
# print('(Step 95A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
# try:
# message2receive4epu = channel4map2imageconsume4epu.recv()
# print("(Step 95B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel4map2imageconsume4epu, " CONTROL & COMMAND: ", message2receive4epu)
# except:
# print('(Step 95Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
#
# # ------------------------------------------------------------------------------------------------------------
# # SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2COPYIMAGE4EPU TO RECEIVE
# # ------------------------------------------------------------------------------------------------------------
# print('(Step 96A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
# try:
# message2send4epu = "ready2mapimage4epu"
# channel4map2imagepublish4epu.send(message2send4epu)
# print("(Step 96B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel4map2imagepublish4epu, " MESSAGE2SEND4EPU: " , message2send4epu)
# except:
# print('(Step 84Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
#
# # -------------------------------------------------------------------------------------------------------
# # SIMULATE MANOEUVRE2COPYIMAGE4EPU - LET IT RECEIVE READY AND SEND READY
# # -------------------------------------------------------------------------------------------------------
# if ack2simulate4epu is True:
# print("(Step 97A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4copy = manoeuvre2mapimage4epu(queue4map2image4epu, channel4map2imageconsume4epu, channel4map2imagepublish4epu)
# print("(Step 97B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", manoeuvre2copyimage4epu)
# except:
# print("(Step 97Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#
#
# # ---------------------------------------------------------------------------------------
# # RECEIVE CONTROL & COMMAND READY VIA PIPE
# # ---------------------------------------------------------------------------------------
# print('(Step 98A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
# try:
# message2receive4epu = channel4map2imageconsume4epu.recv()
# print("(Step 98B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel4map2imageconsume4epu, " CONTROL & COMMAND: ", message2receive4epu)
# except:
# print('(Step 86Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP2IMAGE4EPU ', time4xi())
#
# # -----------------------------------------------------------------------------------------
# # IMAGE EPUXI COPY OPERATIONS
# # -----------------------------------------------------------------------------------------
# print('(Step 99A/700) OF EPU2IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE EPUXI ', time4xi())
# try:
# path2dragon = '..//..//..//..//..//web//images//png//dragonxi.png'
# file2dragon = open(path2dragon)
# print("(Step 99B/700) OF EPU2IMAGE4XI5TEST - FILENO: ", file2epu.fileno( ))
# print("(Step 99C/700) OF EPU2IMAGE4XI5TEST - MODE: ", file2epu.mode)
# print("(Step 99D/700) OF EPU2IMAGE4XI5TEST - NAME: ", file2epu.name)
# offset2epu = 10
# file2epu.seek(offset2epu)
# print("(Step 99E/700) OF EPU2IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset2epu)
# file2epu.close()
# print("(Step 99F/700) OF DRAGON2IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path2dragon)
# except:
# print("(Step 87Z/700) OF DRAGON2IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path2dragon)
#
# # -----------------------------------------------------------------------------------------
# # PUT IMAGE PATH TO QUEUE
# # -----------------------------------------------------------------------------------------
# print("(Step 100A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue4map2image4dragon.put(path2dragon)
# print("(Step 100B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# except:
# print("(Step 88Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
#
# # -------------------------------------------------------------------------------------------------------------------------------------
# # SIMULATE MANOEUVRE2COPYIMAGE4EPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# # -------------------------------------------------------------------------------------------------------------------------------------
# if ack2simulate4epu is True:
# print("(Step 101A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4copy = manoeuvre2mapimage4epu(queue4map2image4epu, channel4map2imageconsume4epu, channel4map2imagepublish4epu)
# print("(Step 101B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", manoeuvre2copyimage4epu)
# except:
# print("(Step 101Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#
#
# # ----------------------------------------------------------------------------------------------------
# # RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# # ----------------------------------------------------------------------------------------------------
# print('(Step 102A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2receive4epu = channel4map2imageconsume4epu.recv()
# print("(Step 102B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel4map2imageconsume4epu, " CONTROL & COMMAND: ", message2receive4epu)
# except:
# print('(Step 90Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
#
# # ----------------------------------------------------------------------------------------------------------------
# # SIMULATE MANOEUVRE2COPYIMAGE4EPU - LET MANOEUVRE2COPYIMAGE4EPU TO GO TO STATE 0
# # ----------------------------------------------------------------------------------------------------------------
# if ack2simulate4epu is True:
# print("(Step 103A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4copy = manoeuvre2mapimage4epu(queue4map2image4epu, channel4map2imageconsume4epu, channel4map2imagepublish4epu)
# print("(Step 103B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvre4copy)
# except:
# print("(Step 103Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#
#">
# -------------------------------------------------------------------------------------------------
def map2image4epu(task4imagemap2epu=None):
'''
maps 2D images for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global control2mapimage4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "map2image4epu"
method2print = "map2image4epu"
message2print = "{(Step 1A/33) started" + "; map2image4epu-started: " + str(map2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4imagemap2epu-to-map2image4epu: " + str(task4imagemap2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) created" + "; epu2image4xi-created-by-map2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-map2image4epu: " + str(map2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-map2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z/70) yielded" + "; epu2image4xi-yielded-by-map2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - CHECK PARAMETERS
# -----------------------------------------------------------------------------------------
try:
if task4imagemap2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR MAP - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4imagemap2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4imagemap2epu-created-by-map2image4epu to: " + str(task4imagemap2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-map2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "map2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "map2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; map2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-map2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagemap2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagemap2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4imagemap2epu-created-by-map2image4epu to: " + str(task4imagemap2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-map2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-map2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-map2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4imagemap2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4imagemap2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4imagemap2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imageinfo2epu-trying-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imageinfo2epu-got-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imageinfo2epu-failed-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4imagemap2epu ['IMAGE'] = imageinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 6A/70) trying" + "; queue2epu-trying-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 6B/70) got" + "; queue2epu-got-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; queue2epu-failed-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4imagemap2epu ['QUEUE'] = queue2epu
# ---------------------------------------------------------------------------------------------
# (7) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 7A/70) trying" + "; pipe2epu-trying-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 7B/70) got" + "; pipe2epu-got-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; pipe2epu-failed-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4imagemap2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (8) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 8A/70) trying" + "; commandqueueinfo2epu-trying-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 8B/70) got" + "; commandqueueinfo2epu-got-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; commandqueueinfo2epu-failed-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4imagemap2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (9) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; bufferinfo2epu-trying-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; bufferinfo2epu-got-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; bufferinfo2epu-failed-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4imagemap2epu ['BUFFER'] = bufferinfo2epu
# ---------------------------------------------------------------------------------------------
# (10) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 10A/70) trying" + "; eventinfo2epu-trying-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 10B/70) got" + "; eventinfo2epu-got-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '10B-'
except:
message2print = "{(Step 10Z/70) failed" + "; eventinfo2epu-failed-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '10Z-'
task4imagemap2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventwaitlist2epu-trying-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 11B/70) set" + "; eventwaitlist2epu-set-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventwaitlist2epu-failed-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4imagemap2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 12A/70) trying" + "; eventwaitlistquantity2epu-trying-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 12B/70) set" + "; eventwaitlistquantity2epu-set-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4imagemap2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (13) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 13A/70) trying" + "; blocking2epu-trying-by-map2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the map command is non-blocking
message2print = "{(Step 13B/70) set" + "; blocking2epu-set-by-map2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; blocking2epu-failed-by-map2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4imagemap2epu ['BLOCKING'] = blocking2epu
# ---------------------------------------------------------------------------------------------
# (14) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 14A/70) trying" + "; origin2epu-trying-by-map2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 14B/70) set" + "; origin2epu-set-by-map2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; origin2epu-failed-by-map2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4imagemap2epu ['ORIGIN'] = origin2epu
# ---------------------------------------------------------------------------------------------
# (15) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 15A/70) trying" + "; region2epu-trying-by-map2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO MAP
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO MAP
region2epu['Z'] = 0 # DEPTH IN PIXELS TO MAP
message2print = "{(Step 15B/70) set" + "; region2epu-set-by-map2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; region2epu-failed-by-map2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '15Z-'
task4imagemap2epu ['REGION'] = region2epu
# ---------------------------------------------------------------------------------------------
# (16) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 8 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 10 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 8 # ONE DIRECTIONS IN 2D
width2epu = 800
message2print = "{(Step 16A/70) trying" + "; rowpitch2epu-trying-by-map2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 16B/70) set" + "; rowpitch2epu-set-by-map2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 8000
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; rowpitch2epu-failed-by-map2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '16Z-'
task4imagemap2epu ['ROWPITCH'] = rowpitch2epu
# --------------------------------------------------------------------------------------------------------
# (18) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING MAP
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 18A/70) trying" + "; slicepitch2epu-trying-by-map2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 18B/70) set" + "; slicepitch2epu-set-by-map2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '18B-'
except:
message2print = "{(Step 18Z/70) failed" + "; slicepitch2epu-failed-by-map2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '18Z-'
task4imagemap2epu ['SLICEPITCH'] = slicepitch2epu
# ---------------------------------------------------------------------------------------------
# (19) FLAGS - REQUIRED
# ---------------------------------------------------------------------------------------------
flags2epu = 'CL_MAP_READ'
message2print = "{(Step 19A/70) trying" + "; flags2epu-trying-by-map2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
flags2epu = 'CL_MAP_WRITE' # THE REGION SPECIFIED BY (ORIGIN, REGION) IN THE IMAGE OBJECT IS BEING MAPPED FOR WRITING
message2print = "{(Step 19B/70) set" + "; flags2epu-set-by-map2image4epu to: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '19B-'
except:
message2print = "{(Step 19Z/70) failed" + "; flags2epu-failed-by-map2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '19Z-'
task4imagemap2epu ['FLAGS'] = flags2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
else:
pass
# ---------------------------------------------------------------------------------------------
# ANALYSE TASKS - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4imagemap2epu.keys()
message2print = "{(Step 20/70) got" + "; keys2task-got-by-map2image4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FLAGS',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SLICEPITCH']; time: 01:28:44 10/05/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-map2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "map2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "map2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; map2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-map2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagemap2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagemap2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4imagemap2epu-created-by-map2image4epu to: " + str(task4imagemap2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-map2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-map2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-map2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4imagemap2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-map2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4imagemap2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-map2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4imagemap2epu ['DEVICE'] = device2epu
if 'IMAGE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; imageinfo2epu-trying-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; imageinfo2epu-got-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; imageinfo2epu-failed-by-map2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4imagemap2epu ['IMAGE'] = imageinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 26A/70) trying" + "; queue2epu-trying-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 26B/70) got" + "; queue2epu-got-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; queue2epu-failed-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4imagemap2epu ['QUEUE'] = queue2epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 27A/70) trying" + "; pipe2epu-trying-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 27B/70) got" + "; pipe2epu-got-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; pipe2epu-failed-by-map2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4imagemap2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 28A/70) trying" + "; commandqueueinfo2epu-trying-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 28B/70) got" + "; commandqueueinfo2epu-got-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; commandqueueinfo2epu-failed-by-map2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4imagemap2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'BUFFER' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (29) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; bufferinfo2epu-trying-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; bufferinfo2epu-got-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; bufferinfo2epu-failed-by-map2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4imagemap2epu ['BUFFER'] = bufferinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (30) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 30A/70) trying" + "; eventinfo2epu-trying-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 30B/70) got" + "; eventinfo2epu-got-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z/70) failed" + "; eventinfo2epu-failed-by-map2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '30Z-'
task4imagemap2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventwaitlist2epu-trying-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 31B/70) set" + "; eventwaitlist2epu-set-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventwaitlist2epu-failed-by-map2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4imagemap2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 32A/70) trying" + "; eventwaitlistquantity2epu-trying-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 32B/70) set" + "; eventwaitlistquantity2epu-set-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-map2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4imagemap2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'BLOCKING' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 33A/70) trying" + "; blocking2epu-trying-by-map2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the map command is non-blocking
message2print = "{(Step 33B/70) set" + "; blocking2epu-set-by-map2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; blocking2epu-failed-by-map2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4imagemap2epu ['BLOCKING'] = blocking2epu
if 'ORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; origin2epu-trying-by-map2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; origin2epu-set-by-map2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; origin2epu-failed-by-map2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4imagemap2epu ['ORIGIN'] = origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (35) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 35A/70) trying" + "; region2epu-trying-by-map2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO MAP
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO MAP
region2epu['Z'] = 0 # DEPTH IN PIXELS TO MAP
message2print = "{(Step 35B/70) set" + "; region2epu-set-by-map2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '35B-'
except:
message2print = "{(Step 35Z/70) failed" + "; region2epu-failed-by-map2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '35Z-'
task4imagemap2epu ['REGION'] = region2epu
if 'ROWPITCH' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 1 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 1 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 1 # ONE DIRECTIONS IN 2D
message2print = "{(Step 36A/70) trying" + "; rowpitch2epu-trying-by-map2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 36B/70) set" + "; rowpitch2epu-set-by-map2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; rowpitch2epu-failed-by-map2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '36Z-'
task4imagemap2epu ['ROWPITCH'] = rowpitch2epu
if 'SLICEPITCH' in keys2task:
pass
else:
# --------------------------------------------------------------------------------------------------------
# (38) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING MAP
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 38A/70) trying" + "; slicepitch2epu-trying-by-map2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 38B/70) set" + "; slicepitch2epu-set-by-map2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '38B-'
except:
message2print = "{(Step 38Z/70) failed" + "; slicepitch2epu-failed-by-map2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '38Z-'
task4imagemap2epu ['SLICEPITCH'] = slicepitch2epu
if 'FLAGS' in keys2task:
pass
else:
# --------------------------------------------------------------------------------------------------------
# (39) FLAGS - REQUIRED
# --------------------------------------------------------------------------------------------------------
flags2epu = 'CL_MAP_READ'
message2print = "{(Step 39A/70) trying" + "; flags2epu-trying-by-map2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
flags2epu = 'CL_MAP_WRITE'
message2print = "{(Step 39B/70) set" + "; flags2epu-set-by-map2image4epu to: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '39B-'
except:
message2print = "{(Step 39Z/70) failed" + "; flags2epu-failed-by-map2image4epu: " + str(flags2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '39Z-'
task4imagemap2epu ['FLAGS'] = flags2epu
# ---------------------------------------------------------------------------------------------
# EOF TASK ANALYSIS
# ---------------------------------------------------------------------------------------------
keys2task = task4imagemap2epu.keys()
message2print = "{(Step 40A/70) set" + "; keys2task-set-by-map2image4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FLAGS',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SLICEPITCH']; time: 01:28:44 10/05/11 Pacific Daylight Time}
except:
message2print = "{(Step 40Z/70) yielded" + "; task4imagemap2epu-yielded-by-map2image4epu: " + str(task4imagemap2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2mapimage4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-map2image4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
#
consumerchannel2epu, publisherchannel2epu = task4imagemap2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2epu-got-by-map2image4epu: " + str(consumerchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2epu-got-by-map2image4epu: " + str(publisherchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2mapimage4epu['CONSUMERCHANNEL'] = consumerchannel2epu
control2mapimage4epu['PUBLISHERCHANNEL'] = publisherchannel2epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2epu = False
queue2epu = None
message2print = "{(Step 41A/70) trying" + "queue2epu-trying-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = task4imagemap2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2epu-got-by-map2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2epu = True
control2mapimage4epu['QUEUE'] = queue2epu
code2ack = code2ack + '41C-'
except:
ack4queue2epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-map2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2mapimage4epu, # in this module to handle queue and pipe channels
# args =(queue2epu, # caller puts and gets - does NOT call any functions
# consumerchannel2epu, publisherchannel2epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-map2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-map2image4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-map2image4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-13B-14B-15B-16B-18B-19B-40D-41C-
message2print = "{(Step 70C/70) returning" + "; control2mapimage4epu-returning-by-map2image4epu: " + str(control2mapimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return control2mapimage4epu
#
# -----------------------------------------------------------------------------------------------------------------------
#roger2copy4epu', 'ACK2INFO4EPU': False, 'MESSAGE2GET4EPU': 'default2copy4epu',
# # 'MESSAGE2RECEIVE4EPU': 'copy2copy4epu',
# 'CODE2ACK4EPU': ' 0D-1C-', 'MESSAGE2PUT4EPU': 'default2copy4epu', 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 1}
# except:
# print("(Step 42Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#">
# -----------------------------------------------------------------------------------------------------------------------
def manoeuvre2copyimage4epu(queue2copymanoeuvre4epu, consumerchannel2copymanoeuvre4epu, publisherchannel2copymanoeuvre4epu):
'''
manoeuvres copy control and command
'''
global state2copyimage4epu # STATE FOR COMMAND AND CONTROL
global max2copyimagestate4epu # MAX FOR STATE
global ack2copyimageinfo4epu # ACK FOR IMAGE INFO
global message2copyimageget4epu
global message2copyimageput4epu
global message2copyimagereceive4epu
global message2copyimagesend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2copyimage4epu"
method2print = "manoeuvre2copyimage4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2copyimage4epu-started: " + str(manoeuvre2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 0B/33) passed" + "; queue2copymanoeuvre4epu-to-manoeuvre2copyimage4epu: " + str(queue2copymanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2copymanoeuvre4epu-to-manoeuvre2copyimage4epu: " + str(consumerchannel2copymanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0D/33) passed" + "; publisherchannel2copymanoeuvre4epu-to-manoeuvre2copyimage4epu: " + str(publisherchannel2copymanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4copy = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2copyimage4epu-try-by-manoeuvre2copyimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2copyimage4epu is None:
state2copyimage4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2copyimage4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(state2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2copyimage4epu-used-by-manoeuvre2copyimage4epu: " + str(state2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2copyimage4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2copyimage4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(state2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2copyimageinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2copyimageinfo4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(ack2copyimageinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2copyimageget4epu = 'default2copy4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2copyimageget4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(message2copyimageget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimageput4epu = 'default2copy4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2copyimageput4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(message2copyimageput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimagereceive4epu = 'default2copy4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2copyimagereceive4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimagesend4epu = 'default2copy4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2copyimagesend4epu-initialized-by-manoeuvre2copyimage4epu to: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
max2copyimagestate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2copyimagestate4epu-initialized-by-manoeuvre2copyimage4epu to: " + str( max2copyimagestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2copyimage4epu = state2copyimage4epu + 1
message2print = "{(Step 0H/33) added" + "; state2copyimage4epu-added-by-manoeuvre2copyimage4epu: " + str(state2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2copyimage4epu > max2copyimagestate4epu:
state2copyimage4epu = 0
message2print = "{(Step 0I/33) set" + "; state2copyimage4epu-set-by-manoeuvre2copyimage4epu to: " + str(state2copyimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2copyimageinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2copyimageinfo4epu-set-by-manoeuvre2copyimage4epu to: " + str(ack2copyimageinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2copyimageget4epu = 'default2copy4epu'
message2print = "{(Step 0K/33) set" + "; message2copyimageget4epu-set-by-manoeuvre2copyimage4epu to: " + str(message2copyimageget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimageput4epu = 'default2copy4epu'
message2print = "{(Step 0L/33) set" + "; message2copyimageput4epu-set-by-manoeuvre2copyimage4epu to: " + str(message2copyimageput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimagereceive4epu = 'default2copy4epu'
message2print = "{(Step 0M/33) set" + "; message2copyimagereceive4epu-set-by-manoeuvre2copyimage4epu to: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
message2copyimagesend4epu = 'default2copy4epu'
message2print = "{(Step 0N/33) set" + "; message2copyimagesend4epu-set-by-manoeuvre2copyimage4epu to: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2copy4epu
max2copyimagestate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2copyimagestate4epu-set-by-manoeuvre2copyimage4epu to: " + str( max2copyimagestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimage4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2copyimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copyimagereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copyimagereceive4epu = consumerchannel2copymanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2copyimagereceive4epu-received-by-manoeuvre2copyimage4epu: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# copy2copy4epu
if message2copyimagereceive4epu == 'copy2copy4epu':
message2copyimagesend4epu = 'roger2copy4epu'
else:
message2copyimagesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copymanoeuvre4epu.send(message2copyimagesend4epu)
message2print = "{(Step 1C/33) sent" + "; message2copyimagesend4epu-sent-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# roger2copy4epu
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2copyimagereceive4epu-failed-by-manoeuvre2copyimage4epu: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimage4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2copyimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copyimagereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copyimagereceive4epu = consumerchannel2copymanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2copyimagereceive4epu-received-by-manoeuvre2copyimage4epu: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ready2copy4epu
if message2copyimagereceive4epu == 'ready2copy4epu':
message2copyimagesend4epu = 'ready2copy4epu'
else:
message2copyimagesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND READY OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copymanoeuvre4epu.send(message2copyimagesend4epu)
message2print = "{(Step 2C/33) sent" + "; message2copyimagesend4epu-sent-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2copyimagereceive4epu-failed-by-manoeuvre2copyimage4epu: " + str(message2copyimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimage4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2copyimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2copymanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2copyimage4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ..//..//..//..//..//web//images//png//dragonxi.png
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2copyimageinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2copyimageinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2copymanoeuvre4epu-failed-by-manoeuvre2copyimage4epu: " + str(queue2copymanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2copyimagesend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2copyimageinfo4epu is True:
message2copyimagesend4epu = 'ack2imageinfo4epu'
else:
message2copyimagesend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2copyimagesend4epu-set-by-manoeuvre2copyimage4epu to: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copyimagesend4epu-failed-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2copymanoeuvre4epu-calling-by-manoeuvre2copyimage4epu: " + str(publisherchannel2copymanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2copyimagesend4epu-passing-to-send-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copyimagesend4epu-failed-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2copymanoeuvre4epu.send(message2copyimagesend4epu)
message2print = "{(Step 4E/33) sent" + "; message2copyimagesend4epu-sent-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2copyimagesend4epu-failed-by-manoeuvre2copyimage4epu: " + str(message2copyimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4copy['ACK2INFO4EPU'] = ack2copyimageinfo4epu
response2manouvre4copy['CODE2ACK4EPU'] = code2ack
response2manouvre4copy['CODE2NACK4EPU'] = code2nack
response2manouvre4copy['MESSAGE2GET4EPU'] = message2copyimageget4epu
response2manouvre4copy['MESSAGE2PUT4EPU'] = message2copyimageput4epu
response2manouvre4copy['MESSAGE2RECEIVE4EPU'] = message2copyimagereceive4epu
response2manouvre4copy['MESSAGE2SEND4EPU'] = message2copyimagesend4epu
response2manouvre4copy['STATE2MANOEUVRE4EPU'] = state2copyimage4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4copy-returning-by-manoeuvre2copyimage4epu: " + str(response2manouvre4copy) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1 {'MESSAGE2SEND4EPU': 'roger2copy4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copy4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2copy4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2copy4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 1}; time: 05:25:15 10/03/11 Pacific Daylight Time}
#2 {'MESSAGE2SEND4EPU': 'ready2copy4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copy4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copy4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2copy4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 2}; time: 05:25:15 10/03/11 Pacific Daylight Time}
#3 {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True,
# 'MESSAGE2GET4EPU': 'default2copy4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copy4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2copy4epu',
# 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 3}; time: 05:25:15 10/03/11 Pacific Daylight Time}
#4 {'MESSAGE2SEND4EPU': 'default2copy4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copy4epu',
# 'MESSAGE2RECEIVE4EPU': 'default2copy4epu',
# 'CODE2ACK4EPU': ' 0D-',
# 'MESSAGE2PUT4EPU': 'default2copy4epu',
# 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 0}; time: 05:25:15 10/03/11 Pacific Daylight Time}
return response2manouvre4copy
#
# -----------------------------------------------------------------------------------------------------------------------
#roger2copyimagetobuffer4epu',
# # 'ACK2INFO4EPU': False,
# # 'MESSAGE2GET4EPU': 'default2copyimagetobuffer4epu',
# # 'MESSAGE2RECEIVE4EPU': 'copy2copyimagetobuffer4epu',
# # 'CODE2ACK4EPU': ' 0D-1C-',
# # 'MESSAGE2PUT4EPU': 'default2copyimagetobuffer4epu',
# # 'CODE2NACK4EPU': ' ',
# # 'STATE2MANOEUVRE4EPU': 1}
# except:
# print("(Step 62Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#">
# -----------------------------------------------------------------------------------------------------------------------
def manoeuvre2copyimagetobuffer4epu(queue2copyimagetobuffermanoeuvre4epu, consumerchannel2copyimagetobuffermanoeuvre4epu, publisherchannel2copyimagetobuffermanoeuvre4epu):
'''
manoeuvres copy control and command for copy2imagetobuffer4epu
'''
global state2copyimagetobuffer4epu # STATE FOR COMMAND AND CONTROL
global max2copyimagetobufferstate4epu # MAX FOR STATE
global ack2copyimagetobufferinfo4epu # ACK FOR IMAGE INFO
global message2copyimagetobufferget4epu
global message2copyimagetobufferput4epu
global message2copyimagetobufferreceive4epu
global message2copyimagetobuffersend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2copyimagetobuffer4epu"
method2print = "manoeuvre2copyimagetobuffer4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2copyimagetobuffer4epu-started: " + str(manoeuvre2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 0B/33) passed" + "; queue2copyimagetobuffermanoeuvre4epu-to-manoeuvre2copyimagetobuffer4epu: " + str(queue2copyimagetobuffermanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2copyimagetobuffermanoeuvre4epu-to-manoeuvre2copyimagetobuffer4epu: " + str(consumerchannel2copyimagetobuffermanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0D/33) passed" + "; publisherchannel2copyimagetobuffermanoeuvre4epu-to-manoeuvre2copyimagetobuffer4epu: " + str(publisherchannel2copyimagetobuffermanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4copyimagetobuffer = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2copyimagetobuffer4epu-try-by-manoeuvre2copyimagetobuffer4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2copyimagetobuffer4epu is None:
state2copyimagetobuffer4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2copyimagetobuffer4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(state2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2copyimagetobuffer4epu-used-by-manoeuvre2copyimagetobuffer4epu: " + str(state2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2copyimagetobuffer4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2copyimagetobuffer4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(state2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2copyimagetobufferinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2copyimagetobufferinfo4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(ack2copyimagetobufferinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2copyimagetobufferget4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2copyimagetobufferget4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobufferput4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2copyimagetobufferput4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobufferreceive4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2copyimagetobufferreceive4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobuffersend4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2copyimagetobuffersend4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
max2copyimagetobufferstate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2copyimagetobufferstate4epu-initialized-by-manoeuvre2copyimagetobuffer4epu to: " + str( max2copyimagetobufferstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2copyimagetobuffer4epu = state2copyimagetobuffer4epu + 1
message2print = "{(Step 0H/33) added" + "; state2copyimagetobuffer4epu-added-by-manoeuvre2copyimagetobuffer4epu: " + str(state2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2copyimagetobuffer4epu > max2copyimagetobufferstate4epu:
state2copyimagetobuffer4epu = 0
message2print = "{(Step 0I/33) set" + "; state2copyimagetobuffer4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(state2copyimagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack2copyimagetobufferinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2copyimagetobufferinfo4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(ack2copyimagetobufferinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobufferget4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0K/33) set" + "; message2copyimagetobufferget4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobufferput4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0L/33) set" + "; message2copyimagetobufferput4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobufferreceive4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0M/33) set" + "; message2copyimagetobufferreceive4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copyimagetobuffersend4epu = 'default2copyimagetobuffer4epu'
message2print = "{(Step 0N/33) set" + "; message2copyimagetobuffersend4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
max2copyimagetobufferstate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2copyimagetobufferstate4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str( max2copyimagetobufferstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimagetobuffer4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2copyimagetobuffer4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copyimagetobufferreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copyimagetobufferreceive4epu = consumerchannel2copyimagetobuffermanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2copyimagetobufferreceive4epu-received-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2copyimagetobufferreceive4epu == 'copy2copyimagetobuffer4epu':
message2copyimagetobuffersend4epu = 'roger2copyimagetobuffer4epu'
else:
message2copyimagetobuffersend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copyimagetobuffermanoeuvre4epu.send(message2copyimagetobuffersend4epu)
message2print = "{(Step 1C/33) sent" + "; message2copyimagetobuffersend4epu-sent-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2copyimagetobufferreceive4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimagetobuffer4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2copyimagetobuffer4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copyimagetobufferreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copyimagetobufferreceive4epu = consumerchannel2copyimagetobuffermanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2copyimagetobufferreceive4epu-received-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2copyimagetobufferreceive4epu == 'ready2copyimagetobuffer4epu':
message2copyimagetobuffersend4epu = 'ready2copyimagetobuffer4epu'
else:
message2copyimagetobuffersend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND READY OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copyimagetobuffermanoeuvre4epu.send(message2copyimagetobuffersend4epu)
message2print = "{(Step 2C/33) sent" + "; message2copyimagetobuffersend4epu-sent-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2copyimagetobufferreceive4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobufferreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2copyimagetobuffer4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2copyimagetobuffer4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2copyimagetobuffermanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2copyimagetobuffer4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ..//..//..//..//..//web//images//png//dragonxi.png
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2copyimagetobufferinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2copyimagetobufferinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2copyimagetobuffermanoeuvre4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(queue2copyimagetobuffermanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2copyimagetobuffersend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2copyimagetobufferinfo4epu is True:
message2copyimagetobuffersend4epu = 'ack2imageinfo4epu'
else:
message2copyimagetobuffersend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2copyimagetobuffersend4epu-set-by-manoeuvre2copyimagetobuffer4epu to: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copyimagetobuffersend4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2copyimagetobuffermanoeuvre4epu-calling-by-manoeuvre2copyimagetobuffer4epu: " + str(publisherchannel2copyimagetobuffermanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2copyimagetobuffersend4epu-passing-to-send-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copyimagetobuffersend4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2copyimagetobuffermanoeuvre4epu.send(message2copyimagetobuffersend4epu)
message2print = "{(Step 4E/33) sent" + "; message2copyimagetobuffersend4epu-sent-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2copyimagetobuffersend4epu-failed-by-manoeuvre2copyimagetobuffer4epu: " + str(message2copyimagetobuffersend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4copyimagetobuffer['ACK2INFO4EPU'] = ack2copyimagetobufferinfo4epu
response2manouvre4copyimagetobuffer['CODE2ACK4EPU'] = code2ack
response2manouvre4copyimagetobuffer['CODE2NACK4EPU'] = code2nack
response2manouvre4copyimagetobuffer['MESSAGE2GET4EPU'] = message2copyimagetobufferget4epu
response2manouvre4copyimagetobuffer['MESSAGE2PUT4EPU'] = message2copyimagetobufferput4epu
response2manouvre4copyimagetobuffer['MESSAGE2RECEIVE4EPU'] = message2copyimagetobufferreceive4epu
response2manouvre4copyimagetobuffer['MESSAGE2SEND4EPU'] = message2copyimagetobuffersend4epu
response2manouvre4copyimagetobuffer['STATE2MANOEUVRE4EPU'] = state2copyimagetobuffer4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4copyimagetobuffer-returning-by-manoeuvre2copyimagetobuffer4epu: " + str(response2manouvre4copyimagetobuffer) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1 {'MESSAGE2SEND4EPU': 'roger2copyimagetobuffer4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copyimagetobuffer4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2copyimagetobuffer4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2copyimagetobuffer4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 1}; time: 02:00:20 10/04/11 Pacific Daylight Time}
#2 {'MESSAGE2SEND4EPU': 'ready2copyimagetobuffer4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copyimagetobuffer4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copyimagetobuffer4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2copyimagetobuffer4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 2}; time: 02:10:33 10/04/11 Pacific Daylight Time}
#3 {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True,
# 'MESSAGE2GET4EPU': 'default2copyimagetobuffer4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copyimagetobuffer4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2copyimagetobuffer4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 3}; time: 02:10:33 10/04/11 Pacific Daylight Time}
#4 {'MESSAGE2SEND4EPU': 'default2copyimagetobuffer4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copyimagetobuffer4epu',
# 'MESSAGE2RECEIVE4EPU': 'default2copyimagetobuffer4epu',
# 'CODE2ACK4EPU': ' 0D-',
# 'MESSAGE2PUT4EPU': 'default2copyimagetobuffer4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 0}; time: 02:10:33 10/04/11 Pacific Daylight Time}
return response2manouvre4copyimagetobuffer
#
# -----------------------------------------------------------------------------------------------------------------------
#roger2copybuffertoimage4epu',
# # 'ACK2INFO4EPU': False,
# # 'MESSAGE2GET4EPU': 'default2copybuffertoimage4epu',
# # 'MESSAGE2RECEIVE4EPU': 'copy2copybuffertoimage4epu',
# # 'CODE2ACK4EPU': ' 0D-1C-',
# # 'MESSAGE2PUT4EPU': 'default2copybuffertoimage4epu',
# # 'CODE2NACK4EPU': ' ',
# # 'STATE2MANOEUVRE4EPU': 1}
# except:
# print("(Step 82Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2COPYIMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
#">
# -----------------------------------------------------------------------------------------------------------------------
def manoeuvre2copybuffertoimage4epu(queue2copybuffertoimagemanoeuvre4epu, consumerchannel2copybuffertoimagemanoeuvre4epu, publisherchannel2copybuffertoimagemanoeuvre4epu):
'''
manoeuvres copy control and command for copy2buffertoimage4epu
'''
global state2copybuffertoimage4epu # STATE FOR COMMAND AND CONTROL
global max2copybuffertoimagestate4epu # MAX FOR STATE
global ack2copybuffertoimageinfo4epu # ACK FOR IMAGE INFO
global message2copybuffertoimageget4epu
global message2copybuffertoimageput4epu
global message2copybuffertoimagereceive4epu
global message2copybuffertoimagesend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2copybuffertoimage4epu"
method2print = "manoeuvre2copybuffertoimage4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2copybuffertoimage4epu-started: " + str(manoeuvre2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 0B/33) passed" + "; queue2copybuffertoimagemanoeuvre4epu-to-manoeuvre2copybuffertoimage4epu: " + str(queue2copybuffertoimagemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2copybuffertoimagemanoeuvre4epu-to-manoeuvre2copybuffertoimage4epu: " + str(consumerchannel2copybuffertoimagemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0D/33) passed" + "; publisherchannel2copybuffertoimagemanoeuvre4epu-to-manoeuvre2copybuffertoimage4epu: " + str(publisherchannel2copybuffertoimagemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4copybuffertoimage = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2copybuffertoimage4epu-try-by-manoeuvre2copybuffertoimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2copybuffertoimage4epu is None:
state2copybuffertoimage4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2copybuffertoimage4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(state2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2copybuffertoimage4epu-used-by-manoeuvre2copybuffertoimage4epu: " + str(state2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2copybuffertoimage4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2copybuffertoimage4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(state2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2copybuffertoimageinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2copybuffertoimageinfo4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(ack2copybuffertoimageinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2copybuffertoimageget4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2copybuffertoimageget4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimageget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimageput4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2copybuffertoimageput4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimageput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimagereceive4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2copybuffertoimagereceive4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimagesend4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2copybuffertoimagesend4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
max2copybuffertoimagestate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2copybuffertoimagestate4epu-initialized-by-manoeuvre2copybuffertoimage4epu to: " + str( max2copybuffertoimagestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2copybuffertoimage4epu = state2copybuffertoimage4epu + 1
message2print = "{(Step 0H/33) added" + "; state2copybuffertoimage4epu-added-by-manoeuvre2copybuffertoimage4epu: " + str(state2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2copybuffertoimage4epu > max2copybuffertoimagestate4epu:
state2copybuffertoimage4epu = 0
message2print = "{(Step 0I/33) set" + "; state2copybuffertoimage4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(state2copybuffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack2copybuffertoimageinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2copybuffertoimageinfo4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(ack2copybuffertoimageinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimageget4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0K/33) set" + "; message2copybuffertoimageget4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimageget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimageput4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0L/33) set" + "; message2copybuffertoimageput4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimageput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimagereceive4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0M/33) set" + "; message2copybuffertoimagereceive4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2copybuffertoimagesend4epu = 'default2copybuffertoimage4epu'
message2print = "{(Step 0N/33) set" + "; message2copybuffertoimagesend4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
max2copybuffertoimagestate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2copybuffertoimagestate4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str( max2copybuffertoimagestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copybuffertoimage4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2copybuffertoimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copybuffertoimagereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copybuffertoimagereceive4epu = consumerchannel2copybuffertoimagemanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2copybuffertoimagereceive4epu-received-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2copybuffertoimagereceive4epu == 'copy2copybuffertoimage4epu':
message2copybuffertoimagesend4epu = 'roger2copybuffertoimage4epu'
else:
message2copybuffertoimagesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copybuffertoimagemanoeuvre4epu.send(message2copybuffertoimagesend4epu)
message2print = "{(Step 1C/33) sent" + "; message2copybuffertoimagesend4epu-sent-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2copybuffertoimagereceive4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2copybuffertoimage4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2copybuffertoimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2copybuffertoimagereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2copybuffertoimagereceive4epu = consumerchannel2copybuffertoimagemanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2copybuffertoimagereceive4epu-received-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2copybuffertoimagereceive4epu == 'ready2copybuffertoimage4epu':
message2copybuffertoimagesend4epu = 'ready2copybuffertoimage4epu'
else:
message2copybuffertoimagesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND READY OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2copybuffertoimagemanoeuvre4epu.send(message2copybuffertoimagesend4epu)
message2print = "{(Step 2C/33) sent" + "; message2copybuffertoimagesend4epu-sent-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2copybuffertoimagereceive4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2copybuffertoimage4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2copybuffertoimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2copybuffertoimagemanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2copybuffertoimage4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ..//..//..//..//..//web//images//png//dragonxi.png
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2copybuffertoimageinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2copybuffertoimageinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2copybuffertoimagemanoeuvre4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(queue2copybuffertoimagemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2copybuffertoimagesend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2copybuffertoimageinfo4epu is True:
message2copybuffertoimagesend4epu = 'ack2imageinfo4epu'
else:
message2copybuffertoimagesend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2copybuffertoimagesend4epu-set-by-manoeuvre2copybuffertoimage4epu to: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copybuffertoimagesend4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2copybuffertoimagemanoeuvre4epu-calling-by-manoeuvre2copybuffertoimage4epu: " + str(publisherchannel2copybuffertoimagemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2copybuffertoimagesend4epu-passing-to-send-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2copybuffertoimagesend4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2copybuffertoimagemanoeuvre4epu.send(message2copybuffertoimagesend4epu)
message2print = "{(Step 4E/33) sent" + "; message2copybuffertoimagesend4epu-sent-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2copybuffertoimagesend4epu-failed-by-manoeuvre2copybuffertoimage4epu: " + str(message2copybuffertoimagesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4copybuffertoimage['ACK2INFO4EPU'] = ack2copybuffertoimageinfo4epu
response2manouvre4copybuffertoimage['CODE2ACK4EPU'] = code2ack
response2manouvre4copybuffertoimage['CODE2NACK4EPU'] = code2nack
response2manouvre4copybuffertoimage['MESSAGE2GET4EPU'] = message2copybuffertoimageget4epu
response2manouvre4copybuffertoimage['MESSAGE2PUT4EPU'] = message2copybuffertoimageput4epu
response2manouvre4copybuffertoimage['MESSAGE2RECEIVE4EPU'] = message2copybuffertoimagereceive4epu
response2manouvre4copybuffertoimage['MESSAGE2SEND4EPU'] = message2copybuffertoimagesend4epu
response2manouvre4copybuffertoimage['STATE2MANOEUVRE4EPU'] = state2copybuffertoimage4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4copybuffertoimage-returning-by-manoeuvre2copybuffertoimage4epu: " + str(response2manouvre4copybuffertoimage) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1 {'MESSAGE2SEND4EPU': 'roger2copybuffertoimage4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copybuffertoimage4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2copybuffertoimage4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2copybuffertoimage4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 1}; time: 02:18:55 10/04/11 Pacific Daylight Time}
#2 {'MESSAGE2SEND4EPU': 'ready2copybuffertoimage4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copybuffertoimage4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copybuffertoimage4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2copybuffertoimage4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 2}; time: 02:18:55 10/04/11 Pacific Daylight Time}
#3 {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True,
# 'MESSAGE2GET4EPU': 'default2copybuffertoimage4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2copybuffertoimage4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2copybuffertoimage4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 3}; time: 02:18:55 10/04/11 Pacific Daylight Time}
#4 {'MESSAGE2SEND4EPU': 'default2copybuffertoimage4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2copybuffertoimage4epu',
# 'MESSAGE2RECEIVE4EPU': 'default2copybuffertoimage4epu',
# 'CODE2ACK4EPU': ' 0D-',
# 'MESSAGE2PUT4EPU': 'default2copybuffertoimage4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 0}
return response2manouvre4copybuffertoimage
#
# -----------------------------------------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------------------------------------
def manoeuvre2readimage4epu(queue2readmanoeuvre4epu, consumerchannel2readmanoeuvre4epu, publisherchannel2readmanoeuvre4epu):
'''
manoeuvres read control and command
'''
global state2read4epu # STATE FOR COMMAND AND CONTROL
global max2readstate4epu # MAX FOR STATE
global ack2readinfo4epu # ACK FOR IMAGE INFO
global message2readget4epu
global message2readput4epu
global message2readreceive4epu
global message2readsend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2readimage4epu"
method2print = "manoeuvre2readimage4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2readimage4epu-started: " + str(manoeuvre2readimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 0B/33) passed" + "; queue2readmanoeuvre4epu-to-manoeuvre2readimage4epu: " + str(queue2readmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2readmanoeuvre4epu-to-manoeuvre2readimage4epu: " + str(consumerchannel2readmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0D/33) passed" + "; publisherchannel2readmanoeuvre4epu-to-manoeuvre2readimage4epu: " + str(publisherchannel2readmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4read = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2read4epu-try-by-manoeuvre2readimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2read4epu is None:
state2read4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2read4epu-initialized-by-manoeuvre2readimage4epu to: " + str(state2read4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2read4epu-used-by-manoeuvre2readimage4epu: " + str(state2read4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2read4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2read4epu-initialized-by-manoeuvre2readimage4epu to: " + str(state2read4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2readinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2readinfo4epu-initialized-by-manoeuvre2readimage4epu to: " + str(ack2readinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2readget4epu = 'default2read4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2readget4epu-initialized-by-manoeuvre2readimage4epu to: " + str(message2readget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readput4epu = 'default2read4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2readput4epu-initialized-by-manoeuvre2readimage4epu to: " + str(message2readput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readreceive4epu = 'default2read4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2readreceive4epu-initialized-by-manoeuvre2readimage4epu to: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readsend4epu = 'default2read4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2readsend4epu-initialized-by-manoeuvre2readimage4epu to: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
max2readstate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2readstate4epu-initialized-by-manoeuvre2readimage4epu to: " + str( max2readstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2read4epu = state2read4epu + 1
message2print = "{(Step 0H/33) added" + "; state2read4epu-added-by-manoeuvre2readimage4epu: " + str(state2read4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2read4epu > max2readstate4epu:
state2read4epu = 0
message2print = "{(Step 0I/33) set" + "; state2read4epu-set-by-manoeuvre2readimage4epu to: " + str(state2read4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2readinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2readinfo4epu-set-by-manoeuvre2readimage4epu to: " + str(ack2readinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2readget4epu = 'default2read4epu'
message2print = "{(Step 0K/33) set" + "; message2readget4epu-set-by-manoeuvre2readimage4epu to: " + str(message2readget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readput4epu = 'default2read4epu'
message2print = "{(Step 0L/33) set" + "; message2readput4epu-set-by-manoeuvre2readimage4epu to: " + str(message2readput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readreceive4epu = 'default2read4epu'
message2print = "{(Step 0M/33) set" + "; message2readreceive4epu-set-by-manoeuvre2readimage4epu to: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
message2readsend4epu = 'default2read4epu'
message2print = "{(Step 0N/33) set" + "; message2readsend4epu-set-by-manoeuvre2readimage4epu to: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2read4epu
max2readstate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2readstate4epu-set-by-manoeuvre2readimage4epu to: " + str( max2readstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2read4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2readimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2readreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2readreceive4epu = consumerchannel2readmanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2readreceive4epu-received-by-manoeuvre2readimage4epu: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# copy2read4epu
if message2readreceive4epu == 'copy2read4epu':
message2readsend4epu = 'roger2read4epu'
else:
message2readsend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2readmanoeuvre4epu.send(message2readsend4epu)
message2print = "{(Step 1C/33) sent" + "; message2readsend4epu-sent-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# roger2read4epu
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2readreceive4epu-failed-by-manoeuvre2readimage4epu: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2read4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2readimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2readreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2readreceive4epu = consumerchannel2readmanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2readreceive4epu-received-by-manoeuvre2readimage4epu: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ready2read4epu
if message2readreceive4epu == 'ready2read4epu':
message2readsend4epu = 'ready2read4epu'
else:
message2readsend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2readmanoeuvre4epu.send(message2readsend4epu)
message2print = "{(Step 2C/33) sent" + "; message2readsend4epu-sent-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ready2read4epu
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2readreceive4epu-failed-by-manoeuvre2readimage4epu: " + str(message2readreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2read4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2readimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2readmanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2readimage4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ..//..//..//..//..//web//images//png//dragonxi.png
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2readinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2readinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2readmanoeuvre4epu-failed-by-manoeuvre2readimage4epu: " + str(queue2readmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2readsend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2readinfo4epu is True:
message2readsend4epu = 'ack2imageinfo4epu'
else:
message2readsend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2readsend4epu-set-by-manoeuvre2readimage4epu to: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
except:
message2print = "{(Step 4Z1/33) failed" + "; message2readsend4epu-failed-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2readmanoeuvre4epu-calling-by-manoeuvre2readimage4epu: " + str(publisherchannel2readmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2readsend4epu-passing-to-send-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2readsend4epu-failed-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2readmanoeuvre4epu.send(message2readsend4epu)
message2print = "{(Step 4E/33) sent" + "; message2readsend4epu-sent-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2readsend4epu-failed-by-manoeuvre2readimage4epu: " + str(message2readsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4read['ACK2INFO4EPU'] = ack2readinfo4epu
response2manouvre4read['CODE2ACK4EPU'] = code2ack
response2manouvre4read['CODE2NACK4EPU'] = code2nack
response2manouvre4read['MESSAGE2GET4EPU'] = message2readget4epu
response2manouvre4read['MESSAGE2PUT4EPU'] = message2readput4epu
response2manouvre4read['MESSAGE2RECEIVE4EPU'] = message2readreceive4epu
response2manouvre4read['MESSAGE2SEND4EPU'] = message2readsend4epu
response2manouvre4read['STATE2MANOEUVRE4EPU'] = state2read4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4read-returning-by-manoeuvre2readimage4epu: " + str(response2manouvre4read) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1 {'MESSAGE2SEND4EPU': 'roger2read4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2read4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2read4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2read4epu',
# 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 1}; time: 01:44:40 09/29/11 Pacific Daylight Time}
#2 {'MESSAGE2SEND4EPU': 'ready2read4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2read4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2read4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2read4epu',
# 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 2}; time: 01:44:40 09/29/11 Pacific Daylight Time}
#3 {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True,
# 'MESSAGE2GET4EPU': 'default2read4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2read4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2read4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 3}; time: 01:44:40 09/29/11 Pacific Daylight Time}
#4 {'MESSAGE2SEND4EPU': 'default2read4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2read4epu',
# 'MESSAGE2RECEIVE4EPU': 'default2read4epu',
# 'CODE2ACK4EPU': ' 0D-',
# 'MESSAGE2PUT4EPU': 'default2read4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 0}; time: 02:11:49 09/29/11 Pacific Daylight Time}
return response2manouvre4read
#
# -------------------------------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------------------------------
def manoeuvre2writeimage4epu(queue2writemanoeuvre4epu, consumerchannel2writemanoeuvre4epu, publisherchannel2writemanoeuvre4epu):
'''
manoeuvres control and command
'''
global state2write4epu # STATE FOR COMMAND AND CONTROL
global max2writestate4epu # MAX FOR STATE
global ack2writeinfo4epu # ACK FOR IMAGE INFO
global message2writeget4epu
global message2writeput4epu
global message2writereceive4epu
global message2writesend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2writeimage4epu"
method2print = "manoeuvre2writeimage4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2writeimage4epu-started: " + str(manoeuvre2writeimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0B/33) passed" + "; queue2writemanoeuvre4epu-to-manoeuvre2writeimage4epu: " + str(queue2writemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2writemanoeuvre4epu-to-manoeuvre2writeimage4epu: " + str(consumerchannel2writemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# read-write PipeConnection, handle 568>
message2print = "{(Step 0D/33) passed" + "; publisherchannel2writemanoeuvre4epu-to-manoeuvre2writeimage4epu: " + str(publisherchannel2writemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4write = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2write4epu-try-by-manoeuvre2writeimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2write4epu is None:
state2write4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2write4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(state2write4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2write4epu-used-by-manoeuvre2writeimage4epu: " + str(state2write4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2write4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2write4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(state2write4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2writeinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2writeinfo4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(ack2writeinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2writeget4epu = 'default2write4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2writeget4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(message2writeget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writeput4epu = 'default2write4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2writeput4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(message2writeput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writereceive4epu = 'default2write4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2writereceive4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writesend4epu = 'default2write4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2writesend4epu-initialized-by-manoeuvre2writeimage4epu to: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
max2writestate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2writestate4epu-initialized-by-manoeuvre2writeimage4epu to: " + str( max2writestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2write4epu = state2write4epu + 1
message2print = "{(Step 0H/33) added" + "; state2write4epu-added-by-manoeuvre2writeimage4epu: " + str(state2write4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2write4epu > max2writestate4epu:
state2write4epu = 0
message2print = "{(Step 0I/33) set" + "; state2write4epu-set-by-manoeuvre2writeimage4epu to: " + str(state2write4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2writeinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2writeinfo4epu-set-by-manoeuvre2writeimage4epu to: " + str(ack2writeinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2writeget4epu = 'default2write4epu'
message2print = "{(Step 0K/33) set" + "; message2writeget4epu-set-by-manoeuvre2writeimage4epu to: " + str(message2writeget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writeput4epu = 'default2write4epu'
message2print = "{(Step 0L/33) set" + "; message2writeput4epu-set-by-manoeuvre2writeimage4epu to: " + str(message2writeput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writereceive4epu = 'default2write4epu'
message2print = "{(Step 0M/33) set" + "; message2writereceive4epu-set-by-manoeuvre2writeimage4epu to: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
message2writesend4epu = 'default2write4epu'
message2print = "{(Step 0N/33) set" + "; message2writesend4epu-set-by-manoeuvre2writeimage4epu to: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2write4epu
max2writestate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2writestate4epu-set-by-manoeuvre2writeimage4epu to: " + str( max2writestate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2write4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2writeimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2writereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2writereceive4epu = consumerchannel2writemanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2writereceive4epu-received-by-manoeuvre2writeimage4epu: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# copy2write4epu
if message2writereceive4epu == 'copy2write4epu':
message2writesend4epu = 'roger2write4epu'
else:
message2writesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2writemanoeuvre4epu.send(message2writesend4epu)
message2print = "{(Step 1C/33) sent" + "; message2writesend4epu-sent-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# roger2write4epu
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2writereceive4epu-failed-by-manoeuvre2writeimage4epu: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2write4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2writeimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2writereceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2writereceive4epu = consumerchannel2writemanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2writereceive4epu-received-by-manoeuvre2writeimage4epu: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ready2write4epu
if message2writereceive4epu == 'ready2write4epu':
message2writesend4epu = 'ready2write4epu'
else:
message2writesend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2writemanoeuvre4epu.send(message2writesend4epu)
message2print = "{(Step 2C/33) sent" + "; message2writesend4epu-sent-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ready2write4epu
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2writereceive4epu-failed-by-manoeuvre2writeimage4epu: " + str(message2writereceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2write4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2writeimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2writemanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2writeimage4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ..//..//..//..//..//web//images//png//dragonxi.png
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2writeinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2writeinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2writemanoeuvre4epu-failed-by-manoeuvre2writeimage4epu: " + str(queue2writemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2writesend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2writeinfo4epu is True:
message2writesend4epu = 'ack2imageinfo4epu'
else:
message2writesend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2writesend4epu-set-by-manoeuvre2writeimage4epu to: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
except:
message2print = "{(Step 4Z1/33) failed" + "; message2writesend4epu-failed-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2writemanoeuvre4epu-calling-by-manoeuvre2writeimage4epu: " + str(publisherchannel2writemanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2writesend4epu-passing-to-send-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2writesend4epu-failed-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2writemanoeuvre4epu.send(message2writesend4epu)
message2print = "{(Step 4E/33) sent" + "; message2writesend4epu-sent-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ack2imageinfo4epu
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2writesend4epu-failed-by-manoeuvre2writeimage4epu: " + str(message2writesend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4write['ACK2INFO4EPU'] = ack2writeinfo4epu
response2manouvre4write['CODE2ACK4EPU'] = code2ack
response2manouvre4write['CODE2NACK4EPU'] = code2nack
response2manouvre4write['MESSAGE2GET4EPU'] = message2writeget4epu
response2manouvre4write['MESSAGE2PUT4EPU'] = message2writeput4epu
response2manouvre4write['MESSAGE2RECEIVE4EPU'] = message2writereceive4epu
response2manouvre4write['MESSAGE2SEND4EPU'] = message2writesend4epu
response2manouvre4write['STATE2MANOEUVRE4EPU'] = state2write4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4write-returning-by-manoeuvre2writeimage4epu: " + str(response2manouvre4write) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1
# {'MESSAGE2SEND4EPU': 'roger2write4epu',
# 'ACK2INFO4EPU': False, 'MESSAGE2GET4EPU': 'default2write4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2write4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2write4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 1}; time: 00:11:53 10/03/11 Pacific Daylight Time}
#2
# {'MESSAGE2SEND4EPU': 'ready2write4epu',
# 'ACK2INFO4EPU': False, 'MESSAGE2GET4EPU': 'default2write4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2write4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2write4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 2}; time: 00:11:53 10/03/11 Pacific Daylight Time}
#3
# {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True, 'MESSAGE2GET4EPU': 'default2write4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2write4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2write4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 3}; time: 00:11:53 10/03/11 Pacific Daylight Time}
return response2manouvre4write
#
# -------------------------------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------------------------------
def manoeuvre2mapimage4epu(queue2mapmanoeuvre4epu, consumerchannel2mapmanoeuvre4epu, publisherchannel2mapmanoeuvre4epu):
'''
manoeuvres control and command
'''
global state2map4epu # STATE FOR COMMAND AND CONTROL
global max2mapstate4epu # MAX FOR STATE
global ack2mapinfo4epu # ACK FOR IMAGE INFO
global message2mapget4epu
global message2mapput4epu
global message2mapreceive4epu
global message2mapsend4epu
# -----------------------------------------------------------------------------------------
# (Step 0/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "manoeuvre2mapimage4epu"
method2print = "manoeuvre2mapimage4epu"
code2ack = ' '
code2nack = ' '
message2print = "{(Step 0A/33) started" + "; manoeuvre2mapimage4epu-started: " + str(manoeuvre2mapimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0B/33) passed" + "; queue2mapmanoeuvre4epu-to-manoeuvre2mapimage4epu: " + str(queue2mapmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0C/33) passed" + "; consumerchannel2mapmanoeuvre4epu-to-manoeuvre2mapimage4epu: " + str(consumerchannel2mapmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0D/33) passed" + "; publisherchannel2mapmanoeuvre4epu-to-manoeuvre2mapimage4epu: " + str(publisherchannel2mapmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '0D-'
response2manouvre4map = {}
# ------------------------------------------------------------------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------------------------------------------------------------------
message2print = "{(Step 0E/70) try" + "; state2map4epu-try-by-manoeuvre2mapimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if state2map4epu is None:
state2map4epu = 0
message2print = "{(Step 0F/33) initialized" + "; state2map4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(state2map4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
message2print = "{(Step 0G/33) used" + "; state2map4epu-used-by-manoeuvre2mapimage4epu: " + str(state2map4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3;
except:
state2map4epu = 0
message2print = "{(Step 0Z1/33) initialized" + "; state2map4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(state2map4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2mapinfo4epu = False
message2print = "{(Step 0Z2/33) initialized" + "; ack2mapinfo4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(ack2mapinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2mapget4epu = 'default2map4epu'
message2print = "{(Step 0Z3/33) initialized" + "; message2mapget4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(message2mapget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapput4epu = 'default2map4epu'
message2print = "{(Step 0Z4/33) initialized" + "; message2mapput4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(message2mapput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapreceive4epu = 'default2map4epu'
message2print = "{(Step 0Z5/33) initialized" + "; message2mapreceive4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapsend4epu = 'default2map4epu'
message2print = "{(Step 0Z6/33) initialized" + "; message2mapsend4epu-initialized-by-manoeuvre2mapimage4epu to: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
max2mapstate4epu = 3
message2print = "{(Step 0Z7/33) initialized" + "; max2mapstate4epu-initialized-by-manoeuvre2mapimage4epu to: " + str( max2mapstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE UPDATE
# ------------------------------------------------------------------------------------------------------------------------
state2map4epu = state2map4epu + 1
message2print = "{(Step 0H/33) added" + "; state2map4epu-added-by-manoeuvre2mapimage4epu: " + str(state2map4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1; 2; 3; 4
if state2map4epu > max2mapstate4epu:
state2map4epu = 0
message2print = "{(Step 0I/33) set" + "; state2map4epu-set-by-manoeuvre2mapimage4epu to: " + str(state2map4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
ack2mapinfo4epu = False
message2print = "{(Step 0J/33) set" + "; ack2mapinfo4epu-set-by-manoeuvre2mapimage4epu to: " + str(ack2mapinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# False
message2mapget4epu = 'default2map4epu'
message2print = "{(Step 0K/33) set" + "; message2mapget4epu-set-by-manoeuvre2mapimage4epu to: " + str(message2mapget4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapput4epu = 'default2map4epu'
message2print = "{(Step 0L/33) set" + "; message2mapput4epu-set-by-manoeuvre2mapimage4epu to: " + str(message2mapput4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapreceive4epu = 'default2map4epu'
message2print = "{(Step 0M/33) set" + "; message2mapreceive4epu-set-by-manoeuvre2mapimage4epu to: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
message2mapsend4epu = 'default2map4epu'
message2print = "{(Step 0N/33) set" + "; message2mapsend4epu-set-by-manoeuvre2mapimage4epu to: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# default2map4epu
max2mapstate4epu = 3
message2print = "{(Step 0O/33) initialized" + "; max2mapstate4epu-set-by-manoeuvre2mapimage4epu to: " + str( max2mapstate4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ------------------------------------------------------------------------------------------------------------------------
# STATE I - RECEIVE CONTROL AND COMMAND COPY MESSAGE VIA PIPE AND SEND ROGER OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2map4epu == 1:
message2print = "{(Step 1A/70) try" + "; receive-try-by-manoeuvre2mapimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2mapreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2mapreceive4epu = consumerchannel2mapmanoeuvre4epu.recv()
message2print = "{(Step 1B/33) received" + "; message2mapreceive4epu-received-by-manoeuvre2mapimage4epu: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2mapreceive4epu == 'copy2mapimage4epu':
message2mapsend4epu = 'roger2mapimage4epu'
else:
message2mapsend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2mapmanoeuvre4epu.send(message2mapsend4epu)
message2print = "{(Step 1C/33) sent" + "; message2mapsend4epu-sent-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1C-'
except:
message2print = "{(Step 1Z/33) failed" + "; message2mapreceive4epu-failed-by-manoeuvre2mapimage4epu: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE II - RECEIVE CONTROL AND COMMAND READY MESSAGE VIA PIPE AND SEND READY OR NEGATIVE BACK
# ------------------------------------------------------------------------------------------------------------------------
if state2map4epu == 2:
message2print = "{(Step 2A/70) try" + "; receive-try-by-manoeuvre2mapimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2mapreceive4epu = ''
try:
# ----------------------------------------------------------------------------------------------------------------
# RECEIVE CONTROL AND COMMAND MESSAGE VIA PIPE
# ----------------------------------------------------------------------------------------------------------------
message2mapreceive4epu = consumerchannel2mapmanoeuvre4epu.recv()
message2print = "{(Step 2B/33) received" + "; message2mapreceive4epu-received-by-manoeuvre2mapimage4epu: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if message2mapreceive4epu == 'ready2mapimage4epu':
message2mapsend4epu = 'ready2mapimage4epu'
else:
message2mapsend4epu = ''
# ----------------------------------------------------------------------------------------------------------------
# SEND ROGER OR NEGATIVE BACK
# ----------------------------------------------------------------------------------------------------------------
publisherchannel2mapmanoeuvre4epu.send(message2mapsend4epu)
message2print = "{(Step 2C/33) sent" + "; message2mapsend4epu-sent-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '2C-'
except:
message2print = "{(Step 2Z/33) failed" + "; message2mapreceive4epu-failed-by-manoeuvre2mapimage4epu: " + str(message2mapreceive4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# STATE III - GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE AND SEND ACK OR NACK VIA PIPE
# ------------------------------------------------------------------------------------------------------------------------
if state2map4epu == 3:
info2image4epu = None
message2print = "{(Step 3A/70) try" + "; info2image4epu-try-by-manoeuvre2mapimage4epu" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
# ----------------------------------------------------------------------------------------------------------------
# GET IMAGE INFORMATION SUCH AS IMAGE PATH VIA QUEUE
# ----------------------------------------------------------------------------------------------------------------
info2image4epu = queue2mapmanoeuvre4epu.get()
message2print = "{(Step 3B/33) got" + "; info2image4epu-got-by-manoeuvre2mapimage4epu: " + str(info2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if info2image4epu is None:
code2nack = code2nack + '3Z1-'
ack2mapinfo4epu = False
else:
code2ack = code2ack + '3C-'
ack2mapinfo4epu = True
except:
message2print = "{(Step 3Z1/33) failed" + "; queue2mapmanoeuvre4epu-failed-by-manoeuvre2mapimage4epu: " + str(queue2mapmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z1-'
message2mapsend4epu = ' '
try:
# ----------------------------------------------------------------------------------------------------------------
# SEND CONTROL INFO ABOUT IMAGE OPERATION - EITHER ACK OR NACK
# ----------------------------------------------------------------------------------------------------------------
if ack2mapinfo4epu is True:
message2mapsend4epu = 'ack2imageinfo4epu'
else:
message2mapsend4epu = 'nack2imageinfo4epu'
message2print = "{(Step 4B/33) set" + "; message2mapsend4epu-set-by-manoeuvre2mapimage4epu to: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2mapsend4epu-failed-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z1-'
try:
message2print = "{(Step 4C/70) using" + "; publisherchannel2mapmanoeuvre4epu-calling-by-manoeuvre2mapimage4epu: " + str(publisherchannel2mapmanoeuvre4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{{(Step 4D/70) passing" + "; message2mapsend4epu-passing-to-send-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4Z1/33) failed" + "; message2mapsend4epu-failed-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z2-'
try:
publisherchannel2mapmanoeuvre4epu.send(message2mapsend4epu)
message2print = "{(Step 4E/33) sent" + "; message2mapsend4epu-sent-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '4E-'
except:
message2print = "{(Step 4Z3/33) failed" + "; message2mapsend4epu-failed-by-manoeuvre2mapimage4epu: " + str(message2mapsend4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z3-'
else:
pass
# ------------------------------------------------------------------------------------------------------------------------
# RETURN
# ------------------------------------------------------------------------------------------------------------------------
response2manouvre4map['ACK2INFO4EPU'] = ack2mapinfo4epu
response2manouvre4map['CODE2ACK4EPU'] = code2ack
response2manouvre4map['CODE2NACK4EPU'] = code2nack
response2manouvre4map['MESSAGE2GET4EPU'] = message2mapget4epu
response2manouvre4map['MESSAGE2PUT4EPU'] = message2mapput4epu
response2manouvre4map['MESSAGE2RECEIVE4EPU'] = message2mapreceive4epu
response2manouvre4map['MESSAGE2SEND4EPU'] = message2mapsend4epu
response2manouvre4map['STATE2MANOEUVRE4EPU'] = state2map4epu
message2print = "{(Step 33/33) returning" + "; response2manouvre4map-returning-by-manoeuvre2mapimage4epu: " + str(response2manouvre4map) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#1 {'MESSAGE2SEND4EPU': 'roger2mapimage4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2map4epu',
# 'MESSAGE2RECEIVE4EPU': 'copy2mapimage4epu',
# 'CODE2ACK4EPU': ' 0D-1C-',
# 'MESSAGE2PUT4EPU': 'default2map4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 1}
#2 {'MESSAGE2SEND4EPU': 'ready2mapimage4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2map4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2mapimage4epu',
# 'CODE2ACK4EPU': ' 0D-2C-',
# 'MESSAGE2PUT4EPU': 'default2map4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 2}; time: 06:49:48 10/04/11 Pacific Daylight Time}
#3 {'MESSAGE2SEND4EPU': 'ack2imageinfo4epu',
# 'ACK2INFO4EPU': True,
# 'MESSAGE2GET4EPU': 'default2map4epu',
# 'MESSAGE2RECEIVE4EPU': 'ready2mapimage4epu',
# 'CODE2ACK4EPU': ' 0D-3C-4E-',
# 'MESSAGE2PUT4EPU': 'default2map4epu',
# 'CODE2NACK4EPU': ' ',
# 'STATE2MANOEUVRE4EPU': 3}; time: 06:49:48 10/04/11 Pacific Daylight Time}
#4 {'MESSAGE2SEND4EPU': 'default2map4epu',
# 'ACK2INFO4EPU': False,
# 'MESSAGE2GET4EPU': 'default2map4epu',
# 'MESSAGE2RECEIVE4EPU': 'default2map4epu',
# 'CODE2ACK4EPU': ' 0D-',
# 'MESSAGE2PUT4EPU': 'default2map4epu',
# 'CODE2NACK4EPU': ' ', 'STATE2MANOEUVRE4EPU': 0}; time: 06:49:48 10/04/11 Pacific Daylight Time}
return response2manouvre4map
#
# -------------------------------------------------------------------------------------------------
#copy2write4epu"
# channel2publish4epu = response4write2image['PUBLISHERCHANNEL']
# channel2publish4epu.send(message2writesend4epu)
# print("(Step 17B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2publish4epu, " MESSAGE2SEND4EPU: " , message2writesend4epu)
# except:
# print('(Step 17Z1/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # ------------------------------------------------------------------------------------------
# # (18) LET MANOEUVRE2IMAGE4EPU TO RECEIVE COPY AND AND SEND ROGER VIA PIPE
# # ------------------------------------------------------------------------------------------
# print("(Step 18C/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2write4epu, channel2consume4epu, channel2publish4epu)
# print("(Step 18D/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 18Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# else:
# pass # trust activated thread
# # ---------------------------------------------------------------------------------------------
# # (19) RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# # ---------------------------------------------------------------------------------------------
# print('(Step 19A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# channel2consume4epu = response4write2image['CONSUMERCHANNEL']
# message2writereceive4epu = channel2consume4epu.recv()
# print("(Step 19B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2consume4epu, " CONTROL & COMMAND: ", message2writereceive4epu)
# # roger2write4epu
# except:
# print('(Step 19Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # ---------------------------------------------------------------------------------------------------
# # (20) SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE2IMAGE4EPU TO RECEIVE
# # ---------------------------------------------------------------------------------------------------
# print('(Step 20A/700) OF EPU2IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# message2writesend4epu = "write2write4epu"
# channel2publish4epu = response4write2image['PUBLISHERCHANNEL']
# channel2publish4epu.send(message2writesend4epu)
# print("(Step 20B/700) OF EPU2IMAGE4XI5TEST - SENT TO CHANNEL2PUBLISH4EPU: ", channel2publish4epu, " MESSAGE2SEND4EPU: " , message2writesend4epu)
# # write2write4epu
# except:
# print('(Step 20Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------
# # (21) LET MANOEUVRE2IMAGE4EPU TO RECEIVE READY AND TO SEND READY
# # -----------------------------------------------------------------------------------
# print("(Step 21A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2write4epu, channel2consume4epu, channel2publish4epu)
# print("(Step 21B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 21Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # ---------------------------------------------------------------------------------------
# # (22) RECEIVE CONTROL & COMMAND READY VIA PIPE
# # ---------------------------------------------------------------------------------------
# print('(Step 22A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# try:
# channel2consume4epu = response4write2image['CONSUMERCHANNEL']
# message2writereceive4epu = channel2consume4epu.recv()
# print("(Step 22B/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2consume4epu, " CONTROL & COMMAND: ", message2writereceive4epu)
# # write2write4epu
# except:
# print('(Step 22Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ2IMAGE4EPU ', time4xi())
# # -----------------------------------------------------------------------------------------
# # (24) PUT IMAGE PATH TO QUEUE
# # -----------------------------------------------------------------------------------------
# print("(Step 24A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
# try:
# queue2write4dragon.put(path2dragon)
# print("(Step 24B/700) OF DRAGON2IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path2dragon)
# # ..//..//..//..//..//web//images//png//dragonxi.png
# except:
# print("(Step 24Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# # ------------------------------------------------------------------------------------------------------
# # (25) LET MANOEUVRE2IMAGE4EPU TO GET FROM QUEUE AND TO SEND EITHER ACK OR NACK VIA PIPE
# # -------------------------------------------------------------------------------------------------------
# print("(Step 25A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2write4epu, channel2consume4epu, channel2publish4epu)
# print("(Step 25B/700) OF EPU2IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", manoeuvre2readimage4epu)
# except:
# print("(Step 25Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# # -----------------------------------------------------------------------------------------------
# # (26) RECEIVE ACK OR NACK ABOUT IMAGE OPERATION VIA PIPE
# # -----------------------------------------------------------------------------------------------
# print('(Step 26A/700) OF EPU2IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# try:
# message2writereceive4epu = channel2consume4epu.recv()
# print("(Step 26D/700) OF EPU2IMAGE4XI5TEST - RECEIVED FROM CHANNEL2CONSUME4EPU: ", channel2consume4epu, " CONTROL & COMMAND: ", message2writereceive4epu)
# # ack2imageinfo4epu
# except:
# print('(Step 26Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# # -------------------------------------------------------------------------------------------------------
# # (27) LET MANOEUVRE2IMAGE4EPU GO TO STATE 0
# # -------------------------------------------------------------------------------------------------------
# print("(Step 27A/700) OF EPU2IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
# try:
# response2manoeuvre4epu = manoeuvre2readimage4epu(queue2write4epu, channel2consume4epu, channel2publish4epu)
# print("(Step 27B/700) OF EPU2IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4EPU ", response2manoeuvre4epu)
# except:
# print("(Step 27Z/700) OF EPU2IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE2IMAGE4EPU ", time4xi())
#">
# -------------------------------------------------------------------------------------------------
def write2image4epu(task4imagewrite2epu=None):
'''
writes 2D images for EPU
'''
global epu2image4xi # 2D-IMAGES FOR EPU
global control2writeimage4epu # COMMAND AND CONTROL FOR EPU IMAGES
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "write2image4epu"
method2print = "write2image4epu"
message2print = "{(Step 1A/33) started" + "; write2image4epu-started: " + str(write2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4imagewrite2epu-to-write2image4epu: " + str(task4imagewrite2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# CREATE EPU2IMAGE4XI IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE FOR EPU
message2print = "{(Step 1C/70) created" + "; epu2image4xi-created-by-write2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1D/70) skipped" + "; create2image4epu-skipped-by-write2image4epu: " + str(write2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# create2image4epu-skipped-by-write2image4epu:
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 1E/70) set" + "; epu2image4xi-set-by-write2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
epu2image4xi = {}
message2print = "{(Step 1Z/70) yielded" + "; epu2image4xi-yielded-by-write2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '1Z-'
# -----------------------------------------------------------------------------------------
# (Step 1/70) - CHECK PARAMETERS
# -----------------------------------------------------------------------------------------
try:
if task4imagewrite2epu is None:
# -----------------------------------------------------------------------------------------
# NO PARAMETERS GIVEN BY CALLER FOR READ - BUILD TASK!
# -----------------------------------------------------------------------------------------
task4imagewrite2epu = {}
message2print = "{(Step 1A/70) initialized" + "; task4imagewrite2epu-created-by-write2image4epu to: " + str(task4imagewrite2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# ---------------------------------------------------------------------------------------------
# (1B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 1B1/70) initialized" + "; function2callback4epu-created-by-write2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '1B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "write2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "write2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; write2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 1B2/70) initialized" + "; args2callback-created-by-write2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 1Z1/33) failed; write2image4epu-failed ; time: 02:32:29 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'write2image4epu',
# 'METHOD': 'write2image4epu'}; time: 02:32:29 10/05/11 Pacific Daylight Time}
code2ack = code2ack + '1B2-'
# ---------------------------------------------------------------------------------------------
# (1C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagewrite2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagewrite2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '1C-'
message2print = "{(Step 1C/70) initialized" + "; task4imagewrite2epu-created-by-write2image4epu to: " + str(task4imagewrite2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'FUNCTION2CALLBACK': ,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; write2image4epu-failed ; time: 02:32:29 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'write2image4epu',
# 'METHOD': 'write2image4epu'}}; time: 02:32:29 10/05/11 Pacific Daylight Time}
# ---------------------------------------------------------------------------------------------
# (2) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 2A/70) initialized" + "; platform2xi-created-by-write2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 2B/70) got" + "; platform2xi-got-by-write2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}; time: 02:32:29 10/05/11 Pacific Daylight Time}
code2ack = code2ack + '2B-'
except:
message2print = "{(Step 2Z/70) failed" + "; platform2xi-failed-by-write2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z-'
task4imagewrite2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
# ---------------------------------------------------------------------------------------------
# (3) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 3A/70) trying" + "; context2epu-trying-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 3B/70) got" + "; context2epu-got-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 02:32:29 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu', ...
code2ack = code2ack + '3B-'
except:
message2print = "{(Step 3Z/70) failed" + "; context2epu-failed-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '3Z-'
task4imagewrite2epu ['CONTEXT'] = context2epu
# ---------------------------------------------------------------------------------------------
# (4) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 4A/70) trying" + "; device2epu-trying-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 4B/70) got" + "; device2epu-got-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568' ...
code2ack = code2ack + '4B-'
except:
message2print = "{(Step 4Z/70) failed" + "; device2epu-failed-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
task4imagewrite2epu ['DEVICE'] = device2epu
# ---------------------------------------------------------------------------------------------
# (5) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 5A/70) trying" + "; imageinfo2epu-trying-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 5B/70) got" + "; imageinfo2epu-got-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': {'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4epu-failed ; time: 02:32:29 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2context4epu',
# 'METHOD': 'create2context4epu'},
# 'FUNCTION2CALLBACK': ,
# 'ACK2RETURN': ' 2A-2C-2D-2E-2B-3B-4B-5B-6B-7B-7B-',
# 'INFO2PRIVATE': None,
# 'PLATFORM': {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1},
# 'NACK2RETURN': ' ',
# 'SIZE2PRIVATE': 0,
# 'PROPERTIES': None},
# 'PIPE': (, ),
# 'COUNT2REFERENCE': 1,
# 'FUNCTION2CALLBACK': ,
# 'COMMANDQUEUE': ...
code2ack = code2ack + '5B-'
except:
message2print = "{(Step 5Z/70) failed" + "; imageinfo2epu-failed-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '5Z-'
task4imagewrite2epu ['IMAGE'] = imageinfo2epu
# ---------------------------------------------------------------------------------------------
# (6) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 6A/70) trying" + "; queue2epu-trying-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 6B/70) got" + "; queue2epu-got-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '6B-'
except:
message2print = "{(Step 6Z/70) failed" + "; queue2epu-failed-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z-'
task4imagewrite2epu ['QUEUE'] = queue2epu
# ---------------------------------------------------------------------------------------------
# (7) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 7A/70) trying" + "; pipe2epu-trying-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 7B/70) got" + "; pipe2epu-got-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# (, )
code2ack = code2ack + '7B-'
except:
message2print = "{(Step 7Z/70) failed" + "; pipe2epu-failed-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z-'
task4imagewrite2epu ['PIPE'] = pipe2epu
# ---------------------------------------------------------------------------------------------
# (8) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 8A/70) trying" + "; commandqueueinfo2epu-trying-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 8B/70) got" + "; commandqueueinfo2epu-got-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4epu-failed ; time: 02:32:29 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2commandqueue4epu',
# 'METHOD': 'create2commandqueue4epu'},
# 'FUNCTION2CALLBACK': ...
code2ack = code2ack + '8B-'
except:
message2print = "{(Step 8Z/70) failed" + "; commandqueueinfo2epu-failed-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z-'
task4imagewrite2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
# ---------------------------------------------------------------------------------------------
# (9) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 9A/70) trying" + "; bufferinfo2epu-trying-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 9B/70) got" + "; bufferinfo2epu-got-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 02:32:28 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'}, ...
code2ack = code2ack + '9B-'
except:
message2print = "{(Step 9Z/70) failed" + "; bufferinfo2epu-failed-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '9Z-'
task4imagewrite2epu ['BUFFER'] = bufferinfo2epu
# ---------------------------------------------------------------------------------------------
# (10) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 10A/70) trying" + "; eventinfo2epu-trying-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 10B/70) got" + "; eventinfo2epu-got-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4epu-failed ; time: 02:32:28 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2event4epu',
# 'METHOD': 'create2event4epu'},
# 'FUNCTION2CALLBACK': , ...
code2ack = code2ack + '10B-'
except:
message2print = "{(Step 10Z/70) failed" + "; eventinfo2epu-failed-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '10Z-'
task4imagewrite2epu ['EVENT'] = eventinfo2epu
# ---------------------------------------------------------------------------------------------
# (11) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 11A/70) trying" + "; eventwaitlist2epu-trying-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 11B/70) set" + "; eventwaitlist2epu-set-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {}
code2ack = code2ack + '11B-'
except:
message2print = "{(Step 11Z/70) failed" + "; eventwaitlist2epu-failed-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '11Z-'
task4imagewrite2epu ['EVENTWAITLIST'] = eventwaitlist2epu
# ---------------------------------------------------------------------------------------------
# (12) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 12A/70) trying" + "; eventwaitlistquantity2epu-trying-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 12B/70) set" + "; eventwaitlistquantity2epu-set-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '12B-'
except:
message2print = "{(Step 12Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '12Z-'
task4imagewrite2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
# ---------------------------------------------------------------------------------------------
# (13) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 13A/70) trying" + "; blocking2epu-trying-by-write2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the write command is non-blocking
message2print = "{(Step 13B/70) set" + "; blocking2epu-set-by-write2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# CL_FALSE
code2ack = code2ack + '13B-'
except:
message2print = "{(Step 13Z/70) failed" + "; blocking2epu-failed-by-write2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '13Z-'
task4imagewrite2epu ['BLOCKING'] = blocking2epu
# ---------------------------------------------------------------------------------------------
# (14) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 14A/70) trying" + "; origin2epu-trying-by-write2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 14B/70) set" + "; origin2epu-set-by-write2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 0, 'X': 0, 'Z': 0}
code2ack = code2ack + '14B-'
except:
message2print = "{(Step 14Z/70) failed" + "; origin2epu-failed-by-write2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '14Z-'
task4imagewrite2epu ['ORIGIN'] = origin2epu
# ---------------------------------------------------------------------------------------------
# (15) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 15A/70) trying" + "; region2epu-trying-by-write2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO READ
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO READ
region2epu['Z'] = 0 # DEPTH IN PIXELS TO READ
message2print = "{(Step 15B/70) set" + "; region2epu-set-by-write2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'Y': 90, 'X': 160, 'Z': 0}
code2ack = code2ack + '15B-'
except:
message2print = "{(Step 15Z/70) failed" + "; region2epu-failed-by-write2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '15Z-'
task4imagewrite2epu ['REGION'] = region2epu
# ---------------------------------------------------------------------------------------------
# (16) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
height2epu = 800
width2epu = 800
rowpitch2epu = 0
size2element = 1 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 1 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 1 # ONE DIRECTIONS IN 2D
message2print = "{(Step 16A/70) trying" + "; rowpitch2epu-trying-by-write2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 16B/70) set" + "; rowpitch2epu-set-by-write2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800
code2ack = code2ack + '16B-'
except:
message2print = "{(Step 16Z/70) failed" + "; rowpitch2epu-failed-by-write2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '16Z-'
task4imagewrite2epu ['ROWPITCH'] = rowpitch2epu
# ----------------------------------------------------------------------------------------------------
# (17) POINTER - REQUIRED - THE POINTER TO A BUFFER IN HOST MEMORY WHERE IMAGE DATA IS TO BE READ FROM
# ----------------------------------------------------------------------------------------------------
pointer2epu = None
size2epu = int(width2epu * height2epu) # CALCULATED MEMORY
if size2epu == 0:
size2epu = 4400 # MINIMUM MEMORY
message2print = "{(Step 17A/70) trying" + "; pointer2epu-trying-by-write2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
arena2epu = Arena4Xi(size2epu) # SYSTEM RESERVER MEMORY FOR IMAGE
message2print = "{(Step 17B/70) got" + "; arena2epu-got-by-write2image4epu: " + str(arena2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
size2arena = arena2epu.size #
message2print = "{(Step 17C/70) got" + "; size2arena-got-by-write2buffer4epu: " + str(size2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 640000
buffer2arena = arena2epu.buffer
message2print = "{(Step 17D/70) got" + "; buffer2arena-got-by-write2buffer4epu: " + str(buffer2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17D-'
if size2arena < size2epu:
size2epu = size2arena # AVAILABLE MEMORY FOR IMAGE
message2print = "{(Step 17E/70) set" + "; size2epu-set-by-write2buffer4epu to: " + str(size2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17E-'
else:
pass
pointer2epu = buffer2arena
message2print = "{(Step 17F/70) set" + "; pointer2epu-set-by-write2buffer4epu to: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '17F-'
except:
message2print = "{(Step 17Z/70) failed" + "; pointer2epu-failed-by-write2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '17Z-'
task4imagewrite2epu ['POINTER'] = pointer2epu
task4imagewrite2epu ['SIZE'] = size2epu # AUTOMATIC BY EPUXI
# --------------------------------------------------------------------------------------------------------
# (18) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING READ
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 18A/70) trying" + "; slicepitch2epu-trying-by-write2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 18B/70) set" + "; slicepitch2epu-set-by-write2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 0
code2ack = code2ack + '18B-'
except:
message2print = "{(Step 18Z/70) failed" + "; slicepitch2epu-failed-by-write2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '18Z-'
task4imagewrite2epu ['SLICEPITCH'] = slicepitch2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER PROVIDING
# ---------------------------------------------------------------------------------------------
else:
pass
# ---------------------------------------------------------------------------------------------
# CHECK PARAMETERS - WHETHER AUTOMATICALLY GENERATED OR USER GIVEN
# ---------------------------------------------------------------------------------------------
keys2task = task4imagewrite2epu.keys()
message2print = "{(Step 20/70) using" + "; keys2task-using-by-write2image4epu: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'POINTER',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SIZE',
# 'SLICEPITCH']; time: 02:45:31 10/05/11 Pacific Daylight Time}
if (('DATA2CALLBACK' in keys2task) and ('FUNCTION2CALLBACK' in keys2task)):
pass
else:
# ---------------------------------------------------------------------------------------------
# (21B) TRACE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
function2callback4epu = trace2image4epu # CALLBACK FUNCTION FOR EPU
message2print = "{(Step 21B1/70) initialized" + "; function2callback4epu-created-by-write2image4epu to: " + str(function2callback4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B1-'
args2callback = {} # CREATE ARGUMENT DICTIONARY FOR CALLBACK FUNCTION
args2callback['CLASS'] = "write2image4epu" # MODULE OF EPUIZED OPENCL MODULE
args2callback['METHOD'] = "write2image4epu" # FUNCTION OF EPUIZED OPENCL MODULE
args2callback['MESSAGE'] = "{(Step 1Z1/33) failed" + "; write2image4epu-failed " + "; time: " + time4xi() + "}" # ERROR MESSAGE FOR EPUIZED OPENCL TO RETURN
message2print = "{(Step 21B2/70) initialized" + "; args2callback-created-by-write2image4epu to: " + str(args2callback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '21B2-'
# ---------------------------------------------------------------------------------------------
# (21C) CALLBACK - AUTOMATIC
# ---------------------------------------------------------------------------------------------
task4imagewrite2epu['DATA2CALLBACK'] = args2callback # USER DATA PASSED TO EPUIZED OPENCL - SEVERAL ARGS PASSED IN ONE DICTIONARY
task4imagewrite2epu['FUNCTION2CALLBACK'] = function2callback4epu # CALLBACK FUNCTION TO CALLED BY OPENCL IN EXCEPTIONS
code2ack = code2ack + '21C-'
message2print = "{(Step 21C/70) initialized" + "; task4imagewrite2epu-created-by-write2image4epu to: " + str(task4imagewrite2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if 'PLATFORM' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (22) PLATFORM - AUTOMATIC
# ---------------------------------------------------------------------------------------------
platform2xi = {}
message2print = "{(Step 22A/70) initialized" + "; platform2xi-created-by-write2image4epu to: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
platform2xi = get2platformids4xi() # PLATFORM IS COMMON TO ALL DEVICES I.E TO DEVICE XI
message2print = "{(Step 22B/70) got" + "; platform2xi-got-by-write2image4epu: " + str(platform2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '22B-'
except:
message2print = "{(Step 22Z/70) failed" + "; platform2xi-failed-by-write2image4epu: " + str(failed) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '22Z-'
task4imagewrite2epu['PLATFORM'] = platform2xi # PLATFORM OF SYSTEM
if 'CONTEXT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (23) CONTEXT - AUTOMATIC
# ---------------------------------------------------------------------------------------------
context2epu = {}
message2print = "{(Step 23A/70) trying" + "; context2epu-trying-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
context2epu = get2context4epu() # NO PARAMETERS - THE SYSTEM CREATES CONTEXT IF REQUIRED
message2print = "{(Step 23B/70) got" + "; context2epu-got-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '23B-'
except:
message2print = "{(Step 23Z/70) failed" + "; context2epu-failed-by-write2image4epu: " + str(context2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '23Z-'
task4imagewrite2epu ['CONTEXT'] = context2epu
if 'DEVICE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (24) DEVICE - AUTOMATIC
# ---------------------------------------------------------------------------------------------
device2epu = {}
message2print = "{(Step 24A/70) trying" + "; device2epu-trying-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
device2epu = get2epu4xi() # THE SYSTEM CREATES DEVICE INFO, IF NECESSARY
message2print = "{(Step 24B/70) got" + "; device2epu-got-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '24B-'
except:
message2print = "{(Step 24Z/70) failed" + "; device2epu-failed-by-write2image4epu: " + str(device2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '24Z-'
task4imagewrite2epu ['DEVICE'] = device2epu
if 'IMAGE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (25) IMAGE - REQUIRED
# ---------------------------------------------------------------------------------------------
imageinfo2epu = {}
message2print = "{(Step 25A/70) trying" + "; imageinfo2epu-trying-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
imageinfo2epu = get2imageinfo4epu()
message2print = "{(Step 25B/70) got" + "; imageinfo2epu-got-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '25B-'
except:
message2print = "{(Step 25Z/70) failed" + "; imageinfo2epu-failed-by-write2image4epu: " + str(imageinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '25Z-'
task4imagewrite2epu ['IMAGE'] = imageinfo2epu
if 'QUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (26) QUEUE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
queue2epu = None
message2print = "{(Step 26A/70) trying" + "; queue2epu-trying-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = Queue4Xi() # THE SYSTEM CREATES QUEUE
message2print = "{(Step 26B/70) got" + "; queue2epu-got-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '26B-'
except:
message2print = "{(Step 26Z/70) failed" + "; queue2epu-failed-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '26Z-'
task4imagewrite2epu ['QUEUE'] = queue2epu
if 'PIPE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (27) PIPE - REQUIRED BY EPUXI
# ---------------------------------------------------------------------------------------------
pipe2epu = None
message2print = "{(Step 27A/70) trying" + "; pipe2epu-trying-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
pipe2epu = Pipe4Xi() # THE SYSTEM CREATES PIPE
message2print = "{(Step 27B/70) got" + "; pipe2epu-got-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '27B-'
except:
message2print = "{(Step 27Z/70) failed" + "; pipe2epu-failed-by-write2image4epu: " + str(pipe2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '27Z-'
task4imagewrite2epu ['PIPE'] = pipe2epu
if 'COMMANDQUEUE' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (28) COMMAND QUEUE - REQUIRED
# ---------------------------------------------------------------------------------------------
commandqueueinfo2epu = {}
message2print = "{(Step 28A/70) trying" + "; commandqueueinfo2epu-trying-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
commandqueueinfo2epu = get2commandqueueinfo4epu() # SYSTEM CREATES COMMAND QUEUE, IF NECESSARY
message2print = "{(Step 28B/70) got" + "; commandqueueinfo2epu-got-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '28B-'
except:
message2print = "{(Step 28Z/70) failed" + "; commandqueueinfo2epu-failed-by-write2image4epu: " + str(commandqueueinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '28Z-'
task4imagewrite2epu ['COMMANDQUEUE'] = commandqueueinfo2epu
if 'BUFFER' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (29) BUFFER - AUTOMATIC BY EPUXI
# ---------------------------------------------------------------------------------------------
bufferinfo2epu = {}
message2print = "{(Step 29A/70) trying" + "; bufferinfo2epu-trying-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
bufferinfo2epu = get2bufferinfo4epu() # SYSTEM CREATES BUFFER FOR EPU, IF NECESSARY
message2print = "{(Step 29B/70) got" + "; bufferinfo2epu-got-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '29B-'
except:
message2print = "{(Step 29Z/70) failed" + "; bufferinfo2epu-failed-by-write2image4epu: " + str(bufferinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '29Z-'
task4imagewrite2epu ['BUFFER'] = bufferinfo2epu
if 'EVENT' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (30) EVENT - REQUIRED
# ---------------------------------------------------------------------------------------------
eventinfo2epu = {}
message2print = "{(Step 30A/70) trying" + "; eventinfo2epu-trying-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventinfo2epu = get2eventinfo4epu()
message2print = "{(Step 30B/70) got" + "; eventinfo2epu-got-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '30B-'
except:
message2print = "{(Step 30Z/70) failed" + "; eventinfo2epu-failed-by-write2image4epu: " + str(eventinfo2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '30Z-'
task4imagewrite2epu ['EVENT'] = eventinfo2epu
if 'EVENTWAITLIST' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (31) EVENTWAITLIST - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlist2epu = {}
message2print = "{(Step 31A/70) trying" + "; eventwaitlist2epu-trying-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
eventwaitlist2epu = {}
message2print = "{(Step 31B/70) set" + "; eventwaitlist2epu-set-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '31B-'
except:
message2print = "{(Step 31Z/70) failed" + "; eventwaitlist2epu-failed-by-write2image4epu: " + str(eventwaitlist2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '31Z-'
task4imagewrite2epu ['EVENTWAITLIST'] = eventwaitlist2epu
if 'EVENTWAITLISTQUANTITY' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (32) EVENTWAITLISTQUANTITY - REQUIRED
# ---------------------------------------------------------------------------------------------
eventwaitlistquantity2epu = 0
message2print = "{(Step 32A/70) trying" + "; eventwaitlistquantity2epu-trying-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
keys2event = eventwaitlist2epu.keys()
for key2event in keys2event:
eventwaitlistquantity2epu = eventwaitlistquantity2epu + 1
message2print = "{(Step 32B/70) set" + "; eventwaitlistquantity2epu-set-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '32B-'
except:
message2print = "{(Step 32Z/70) failed" + "; eventwaitlistquantity2epu-failed-by-write2image4epu: " + str(eventwaitlistquantity2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '32Z-'
task4imagewrite2epu ['EVENTWAITLISTQUANTITY'] = eventwaitlistquantity2epu
if 'BLOCKING' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (33) BLOCKING - REQUIRED
# ---------------------------------------------------------------------------------------------
blocking2epu = ' '
message2print = "{(Step 33A/70) trying" + "; blocking2epu-trying-by-write2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
blocking2epu = 'CL_FALSE' # the write command is non-blocking
message2print = "{(Step 33B/70) set" + "; blocking2epu-set-by-write2image4epu to: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '33B-'
except:
message2print = "{(Step 33Z/70) failed" + "; blocking2epu-failed-by-write2image4epu: " + str(blocking2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '33Z-'
task4imagewrite2epu ['BLOCKING'] = blocking2epu
if 'ORIGIN' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (34) ORIGIN - REQUIRED
# ---------------------------------------------------------------------------------------------
origin2epu = {}
message2print = "{(Step 34A/70) trying" + "; origin2epu-trying-by-write2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
origin2epu['X'] = 0
origin2epu['Y'] = 0
origin2epu['Z'] = 0
message2print = "{(Step 34B/70) set" + "; origin2epu-set-by-write2image4epu to: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '34B-'
except:
message2print = "{(Step 34Z/70) failed" + "; origin2epu-failed-by-write2image4epu: " + str(origin2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '34Z-'
task4imagewrite2epu ['ORIGIN'] = origin2epu
if 'REGION' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (35) REGION - REQUIRED
# ---------------------------------------------------------------------------------------------
region2epu = {}
message2print = "{(Step 35A/70) trying" + "; region2epu-trying-by-write2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
region2epu['X'] = 160 # WIDTH IN PIXELS TO WRITE
region2epu['Y'] = 90 # HEIGHT IN PIXELS TO WRITE
region2epu['Z'] = 0 # DEPTH IN PIXELS TO WRITE
message2print = "{(Step 35B/70) set" + "; region2epu-set-by-write2image4epu to: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '35B-'
except:
message2print = "{(Step 35Z/70) failed" + "; region2epu-failed-by-write2image4epu: " + str(region2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '35Z-'
task4imagewrite2epu ['REGION'] = region2epu
if 'ROWPITCH' in keys2task:
pass
else:
# ---------------------------------------------------------------------------------------------
# (36) ROWPITCH (STRIDE) - REQUIRED
# ---------------------------------------------------------------------------------------------
# One can assume that memory representing an image or screen will have data laid out as one row of pixels followed directly by the next row of pixels.
# However many APIs (e.g. Direct3D) that return a pointer to image data add an extra block of data at the end of each row.
# int offset = x * bytesPerPixel + y * pitch;
# When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels.
# The padding bytes affect how the image is stored in memory, but do not affect how the image is displayed.
# The stride is the number of bytes from one row of pixels in memory to the next row of pixels in memory.
# Stride is also called pitch.
# If padding bytes are present, the stride is wider than the width of the image, as shown in the following illustration.
rowpitch2epu = 0
size2element = 1 # VOXEL (X,Y,Z) = SHOT IN PIXELS, R=1 PIXELS
voxelquantity2layer = 1 # MAX NUMBER OF VOXELS IN EACH 2D LAYER
quantity2direction = 1 # ONE DIRECTIONS IN 2D
message2print = "{(Step 36A/70) trying" + "; rowpitch2epu-trying-by-write2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try: # X-AXEL IS THE WORST CASE TO SCAN WITH Y=0, Z=0
rowpitch2epu = int(width2epu * size2element * voxelquantity2layer / quantity2direction) # (800 * 8 * 10) / 8 = 8K PIXELS MAX TO SCAN
# SPHERE IS SPARSE HAVING FEW SHOTS PER SCAN LINE
message2print = "{(Step 36B/70) set" + "; rowpitch2epu-set-by-write2image4epu to: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '36B-'
except:
message2print = "{(Step 36Z/70) failed" + "; rowpitch2epu-failed-by-write2image4epu: " + str(rowpitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '36Z-'
task4imagewrite2epu ['ROWPITCH'] = rowpitch2epu
if 'POINTER' in keys2task:
pass
else:
# ----------------------------------------------------------------------------------------------------
# (37) POINTER - REQUIRED - THE POINTER TO A BUFFER IN HOST MEMORY WHERE IMAGE DATA IS TO BE READ FROM
# ----------------------------------------------------------------------------------------------------
pointer2epu = None
size2epu = int(width2epu * height2epu) # CALCULATED MEMORY
if size2epu == 0:
size2epu = 4400 # MINIMUM MEMORY
message2print = "{(Step 37A/70) trying" + "; pointer2epu-trying-by-write2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
arena2epu = Arena4Xi(size2epu) # SYSTEM RESERVER MEMORY FOR IMAGE
message2print = "{(Step 37B/70) got" + "; arena2epu-got-by-write2image4epu: " + str(arena2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
size2arena = arena2epu.size #
message2print = "{(Step 37C/70) got" + "; size2arena-got-by-write2buffer4epu: " + str(size2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
buffer2arena = arena2epu.buffer
message2print = "{(Step 37D/70) got" + "; buffer2arena-got-by-write2buffer4epu: " + str(buffer2arena) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37D-'
if size2arena < size2epu:
size2epu = size2arena # AVAILABLE MEMORY FOR IMAGE
message2print = "{(Step 37E/70) set" + "; size2epu-set-by-write2buffer4epu to: " + str(size2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37E-'
else:
pass
pointer2epu = buffer2arena
message2print = "{(Step 37F/70) set" + "; pointer2epu-set-by-write2buffer4epu to: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '37F-'
except:
message2print = "{(Step 37Z/70) failed" + "; pointer2epu-failed-by-write2image4epu: " + str(pointer2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '37Z-'
task4imagewrite2epu ['POINTER'] = pointer2epu
task4imagewrite2epu ['SIZE'] = size2epu # AUTOMATIC BY EPUXI
if 'SLICEPITCH' in keys2task:
pass
else:
# --------------------------------------------------------------------------------------------------------
# (38) SLICEPITCH - REQUIRED - THE SIZE IN BYTES OF THE 2D SLICE OF THE 3D REGION OF A 3D IMAGE BEING READ
# --------------------------------------------------------------------------------------------------------
slicepitch2epu = None # SLICEPITCH IS ZERO FOR 2D IMAGES
message2print = "{(Step 38A/70) trying" + "; slicepitch2epu-trying-by-write2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
slicepitch2epu = 0
message2print = "{(Step 38B/70) set" + "; slicepitch2epu-set-by-write2image4epu to: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2ack = code2ack + '38B-'
except:
message2print = "{(Step 38Z/70) failed" + "; slicepitch2epu-failed-by-write2image4epu: " + str(slicepitch2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '38Z-'
task4imagewrite2epu ['SLICEPITCH'] = slicepitch2epu
# ---------------------------------------------------------------------------------------------
# EOF PARAMETER CHECKING AND PROVIDING FOR MISSING ONES
# ---------------------------------------------------------------------------------------------
keys2task = task4imagewrite2epu.keys()
message2print = "{(Step 39/70) set" + "; keys2task-set-by-write2image4epu to: " + str(sorted(keys2task)) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# ['BLOCKING',
# 'BUFFER',
# 'COMMANDQUEUE',
# 'CONTEXT',
# 'DATA2CALLBACK',
# 'DEVICE',
# 'EVENT',
# 'EVENTWAITLIST',
# 'EVENTWAITLISTQUANTITY',
# 'FUNCTION2CALLBACK',
# 'IMAGE',
# 'ORIGIN',
# 'PIPE',
# 'PLATFORM',
# 'POINTER',
# 'QUEUE',
# 'REGION',
# 'ROWPITCH',
# 'SIZE',
# 'SLICEPITCH']; time: 02:45:31 10/05/11 Pacific Daylight Time}
except:
message2print = "{(Step 39Z/70) yielded" + "; task4imagewrite2epu-yielded-by-write2image4epu: " + str(task4imagewrite2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '39Z-'
# ---------------------------------------------------------------------------------------------
# CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
control2writeimage4epu = {}
# ---------------------------------------------------------------------------------------------
# CONSUMER AND PUBLISHER CHANNEL FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4channels2epu = False
channels2epu = ()
message2print = "{(Step 40A/70) trying" + "channels2epu-trying-by-write2image4epu: " + str(channels2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
#
consumerchannel2epu, publisherchannel2epu = task4imagewrite2epu ['PIPE']
message2print = "{(Step 40B/70) got" + "; consumerchannel2epu-got-by-write2image4epu: " + str(consumerchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 40C/70) got" + "; publisherchannel2epu-got-by-write2image4epu: " + str(publisherchannel2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4channels2epu = True
control2writeimage4epu['CONSUMERCHANNEL'] = consumerchannel2epu
control2writeimage4epu['PUBLISHERCHANNEL'] = publisherchannel2epu
code2ack = code2ack + '40D-'
except:
ack4channels2epu = False
code2nack = code2nack + '40Z-'
# ---------------------------------------------------------------------------------------------
# QUEUE FOR CONTROL AND COMMAND
# ---------------------------------------------------------------------------------------------
ack4queue2epu = False
queue2epu = None
message2print = "{(Step 41A/70) trying" + "queue2epu-trying-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
queue2epu = task4imagewrite2epu ['QUEUE']
message2print = "{(Step 41B/70) got" + "; queue2epu-got-by-write2image4epu: " + str(queue2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
ack4queue2epu = True
control2writeimage4epu['QUEUE'] = queue2epu
code2ack = code2ack + '41C-'
except:
ack4queue2epu = False
code2nack = code2nack + '41Z-'
# -----------------------------------------------------------------------------------------
# DUMMY PROCESS OBJECT = THREAD CREATION
# -----------------------------------------------------------------------------------------
# dummy2image4epu = None
# message2print = "{(Step 69A/70) trying" + "dummy2image4epu-trying-by-write2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# try:
# dummy2image4epu = DummyProcess4Xi(target=manoeuvre2readimage4epu, # in this module to handle queue and pipe channels
# args =(queue2epu, # caller puts and gets - does NOT call any functions
# consumerchannel2epu, publisherchannel2epu)) # caller sends and receives - does NOT call any functions
# message2print = "{(Step 69B/70) created" + "dummy2image4epu-created-by-write2image4epu: " + str(dummy2image4epu) + "; time: " + time4xi() + "}"
# print4xi(class2print, method2print, message2print)
# code2ack = code2ack + '69B-'
# except:
# code2nack = code2nack + '69Z-'
# ---------------------------------------------------------------------------------------------
# RETURN CONTROL AND COMMAND DICTIONARY
# ---------------------------------------------------------------------------------------------
message2print = "{(Step 70A/70) set" + "; code2ack-set-by-write2image4epu: " + str(code2ack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 1B1-1B2-1C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-13B-14B-15B-16B-17D-17F-18B-40D-41C-
message2print = "{(Step 70B/70) set" + "; code2nack-set-by-write2image4epu: " + str(code2nack) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 70C/70) returning" + "; control2writeimage4epu-returning-by-write2image4epu: " + str(control2writeimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 02:45:31 10/05/11 Pacific Daylight Time}
return control2writeimage4epu
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def release2image4epu(task4release2epu=None):
'''
releases epu2image4xi
'''
global epu2image4xi
global code2ack
global code2nack
# -----------------------------------------------------------------------------------------
# (Step 1/33) PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "release2image4epu"
method2print = "release2image4epu"
message2print = "{(Step 1A/33) started" + "; release2image4epu-started: " + str(release2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4release2epu-to-release2image4epu: " + str(task4release2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 1}
code2ack = ' '
code2nack = ' '
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu() # INITIALIZE IMAGE
except:
try:
epu2image4xi = create2image4epu()
except:
epu2image4xi = {}
message2print = "{(Step 2Z0/70) yielded" + "; epu2image4xi-yielded-by-release2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '2Z0-'
message2print = "{(Step 1A/70) try" + "; release-try-by-release2image4epu: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
if task4release2epu is None:
task4release2epu = {}
task4release2epu['COUNT2REFERENCE'] = 1
try:
# -----------------------------------------------------------------------------------------
# RELEASE
# -----------------------------------------------------------------------------------------
epu2image4xi['COUNT2REFERENCE'] = epu2image4xi['COUNT2REFERENCE'] - task4release2epu['COUNT2REFERENCE']
message2print = "{(Step 1A/70) calculated" + "; count2reference-calculated-by-release2image4epu: " + str(epu2image4xi['COUNT2REFERENCE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if epu2image4xi['COUNT2REFERENCE'] < 0:
epu2image4xi['COUNT2REFERENCE'] = 0
message2print = "{(Step 1B/70) warning" + "; count2reference-warning-by-release2image4epu: " + " ** " + str(epu2image4xi['COUNT2REFERENCE']) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# { release2image4epu : release2image4epu ; (Step 8Z1/70) warning; count2reference-warning-by-release2image4epu: ** 0 ** ; time: 23:41:37 09/06/11 Pacific Daylight Time}
code2nack = code2nack + '1B-'
else:
code2ack = code2ack + '1B-'
except:
try:
epu2image4xi['COUNT2REFERENCE'] = 0
message2print = "{(Step 8Z1/70) warning" + "; count2reference-warning-by-release2image4epu: " + " ** " + str(epu2image4xi['COUNT2REFERENCE']) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
code2nack = code2nack + '8Z1-'
except:
message2print = "{(Step 8Z2/70) yielded" + "; epu2image4xi-yielded-by-release2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '8Z2-'
# -----------------------------------------------------------------------------------------
# (Step 70/70)
# -----------------------------------------------------------------------------------------
epu2image4xi ['ACK2RETURN'] = code2ack
epu2image4xi ['NACK2RETURN'] = code2nack
message2print = "{(Step 70/70) returning" + "; epu2image4xi-returning-by-release2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' ',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 23:41:37 09/06/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'},
# 'WIDTH': 800,
# 'BUFFER': {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 23:41:37 09/06/11 Pacific Daylight Time}', 'CLASS': 'create2buffer4epu', 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0, 'CONTEXT': {'COUNT2REFERENCE': 0, ...
return epu2image4xi
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def retain2image4epu(task4retain2epu=None):
'''
retains either epu2image4xi
'''
global epu2image4xi
global code2ack
global code2nack
# -----------------------------------------------------------------------------------------
# (Step 1/70) - PARAMETERS
# -----------------------------------------------------------------------------------------
class2print = "retain2image4epu"
method2print = "retain2image4epu"
message2print = "{(Step 1A/33) started" + "; retain2image4epu-started: " + str(retain2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
#
message2print = "{(Step 1B/33) passed" + "; task4retain2epu-to-retain2image4epu: " + str(task4retain2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 1, 'DIMENSION': 2}
# {'COUNT2REFERENCE': 1, 'DIMENSION': 3}
code2ack = ' '
code2nack = ' '
# -----------------------------------------------------------------------------------------
# (Step 2/70) - PROVIDE TASKS, IF NECESSARY AND CHECK GIVEN TASKS
# -----------------------------------------------------------------------------------------
if task4retain2epu is None:
task4retain2epu = {}
task4retain2epu['DIMENSION'] = 2
task4retain2epu['COUNT2REFERENCE'] = 1
message2print = "{(Step 2A/33) set" + "; task4retain2epu-set-by-retain2image4epu to: " + str(task4retain2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
pass
if 'DIMENSION' in task4retain2epu.keys():
if task4retain2epu['DIMENSION'] == 2:
pass
else:
task4retain2epu['DIMENSION'] = 2
message2print = "{(Step 2B/33) set" + "; dimension-set-by-retain2image4epu to: " + str(task4retain2epu['DIMENSION']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
task4retain2epu['DIMENSION'] = 2
# -----------------------------------------------------------------------------------------
# (Step 3/70) - CHECK COUNT2REFERENCE
# -----------------------------------------------------------------------------------------
if 'COUNT2REFERENCE' in task4retain2epu.keys():
pass
else:
task4retain2epu['COUNT2REFERENCE'] = 1
message2print = "{(Step 3A/33) set" + "; count2reference-set-by-retain2image4epu to: " + str(task4retain2epu['COUNT2REFERENCE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if task4retain2epu['COUNT2REFERENCE'] < 1:
task4retain2epu['COUNT2REFERENCE'] = 1
message2print = "{(Step 3B/33) set" + "; count2reference-set-by-retain2image4epu to: " + str(task4retain2epu['COUNT2REFERENCE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 4/70) - INITIALIZE 2D IMAGE IF NECESSARY
# -----------------------------------------------------------------------------------------
try:
if epu2image4xi is None:
epu2image4xi = create2image4epu()
message2print = "{(Step 4A/70) created" + "; epu2image4xi-created-by-retain2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
except:
try:
epu2image4xi = create2image4epu()
message2print = "{(Step 4B/70) created" + "; epu2image4xi-created-by-retain2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
except:
epu2image4xi = {}
message2print = "{(Step 4Z/70) yielded" + "; epu2image4xi-yielded-by-retain2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '4Z-'
# -----------------------------------------------------------------------------------------
# (Step 5/70) - RETAIN
# -----------------------------------------------------------------------------------------
try:
epu2image4xi['COUNT2REFERENCE'] = epu2image4xi['COUNT2REFERENCE'] + task4retain2epu['COUNT2REFERENCE']
message2print = "{(Step 6A/70) calculated" + "; count2reference-calculated-by-retain2image4epu: " + str(epu2image4xi['COUNT2REFERENCE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if epu2image4xi['COUNT2REFERENCE'] <= 0:
epu2image4xi['COUNT2REFERENCE'] = 1
message2print = "{(Step 6Z1/70) warning" + "; count2reference-warning-by-retain2image4epu: " + " ** " + str(epu2image4xi['COUNT2REFERENCE']) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '6Z1-'
else:
code2ack = code2ack + '6C-'
except:
try:
epu2image4xi['COUNT2REFERENCE'] = 1
message2print = "{(Step 7Z1/70) warning" + "; count2reference-warning-by-retain2image4epu: " + " ** " + str(epu2image4xi['COUNT2REFERENCE']) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z1-'
except:
message2print = "{(Step 7Z2/70) yielded" + "; epu2image4xi-yielded-by-retain2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
code2nack = code2nack + '7Z2-'
# -----------------------------------------------------------------------------------------
# (Step 70/70) - RETURN
# -----------------------------------------------------------------------------------------
epu2image4xi ['ACK2RETURN'] = code2ack
epu2image4xi ['NACK2RETURN'] = code2nack
message2print = "{(Step 70A/70) returning" + "; epu2image4xi-returning-by-retain2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0, 'ACK2RETURN': ' 6C-', 'ROWPITCH': 800, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 23:25:02 10/05/11 Pacific Daylight Time}', 'CLASS': 'create2image4epu', 'METHOD': 'create2image4epu'}, 'WIDTH': 800, 'BUFFER': {'CODE2ERROR': 0,
# 'COUNT2REFERENCE': 0, ...
# 'COUNT2REFERENCE': 1,
# 'FLAGS': 0, 'CONTEXT': ...
return epu2image4xi
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def get2imageinfo4epu(task4getinfo2image=None):
'''
gets epu2image4xi
'''
global epu2image4xi
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "get2imageinfo4epu"
method2print = "get2imageinfo4epu"
message2print = "{(Step 0A/33) started" + "; get2imageinfo4epu-started: " + str(get2imageinfo4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0A/33) passed" + "; task4getinfo2image-passed-to-get2imageinfo4epu: " + str(task4getinfo2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'WIDTH': 0, 'DIMENSION': 2, 'HEIGHT': 0}
# {'WIDTH': 0, 'DEPTH': 0, 'DIMENSION': 3, 'HEIGHT': 0}
# {'DOMAIN': 'ALL', 'DIMENSION': 2}
image2epu = {}
try:
if epu2image4xi is None:
# -------------------------------------------------------------------------------------
# INITIALIZE 2D IMAGE FOR EPU
# -------------------------------------------------------------------------------------
image2epu = create2image4epu()
message2print = "{(Step 1B2/33) initialized" + "; image2epu-initialized-by-get2imageinfo4epu to: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1B2/33) using" + "; epu2image4xi-using-by-get2imageinfo4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-14B-15B-16B-17B-17D-18B-18C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-34H-35H-36B-37B-38B-',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 09:05:31 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'},
# 'WIDTH': 800,
# 'BUFFER': ...
# -------------------------------------------------------------------------------------
# RETURN THE WHOLE OR PART OF THE IMAGE INFO OF EPU
# -------------------------------------------------------------------------------------
dimension2xi = 0
if task4getinfo2image is None:
task4getinfo2image = {}
task4getinfo2image ['DIMENSION'] = 2
task4getinfo2image ['DOMAIN'] = 'ALL'
image2epu = epu2image4xi
message2print = "{(Step 1C/33) using" + "; image2epu-got-by-get2imageinfo4epu: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'DOMAIN': 'ALL',
# 'CONTEXT': ...
else:
pass
keys2task4imageinfo = task4getinfo2image.keys()
if 'DIMENSION' in keys2task4imageinfo:
dimension2xi = task4getinfo2image['DIMENSION']
if dimension2xi == 2:
pass
else:
dimension2xi = 2
else:
pass
if 'DOMAIN' in keys2task4imageinfo:
domain2xi = task4getinfo2image['DOMAIN']
if domain2xi == 'ALL':
pass
else:
domain2xi = 'ALL'
keys2domain = epu2image4xi.keys()
for key2domain in keys2domain:
task4getinfo2image[key2domain] = epu2image4xi[key2domain]
message2print = "{(Step 1C/33) using" + "; task4getinfo2image-using-by-get2imageinfo4epu: " + str(task4getinfo2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
else:
pass
keys2task = task4getinfo2image.keys()
for key2task in keys2task:
try:
message2print = "{(Step 2D2/33) using" + "; key2task-using-by-get2image4epu: " + str(key2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# WIDTH; DIMENSION; HEIGHT
image2epu [key2task] = epu2image4xi[key2task]
message2print = "{(Step 2D2/33) set" + "; info-of-image2epu-set-by-get2imageinfo4epu to: " + str(image2epu [key2task]) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 800; 800
except:
message2print = "{(Step 2Z/70) yielded" + "; key2task-yielded-by-get2image4epu: " + str(key2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# DIMENSION;
message2print = "{(Step 2Z2/70) using" + "; task4getinfo2image-using-by-get2image4epu: " + str(task4getinfo2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 2Z3/70) using" + "; epu2image4xi-using-by-get2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
try:
# -------------------------------------------------------------------------------------
# INITIALIZE
# -------------------------------------------------------------------------------------
image2epu = create2image4epu()
message2print = "{(Step 1F/33) initialized" + "; image2epu-initialized-by-get2imageinfo4epu to: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if task4getinfo2image is None:
image2epu = epu2image4xi
message2print = "{(Step 1G/33) got" + "; image2epu-got-by-get2imageinfo4epu: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
keys2task = task4getinfo2image.keys()
for key2task in keys2task:
try:
message2print = "{(Step HD2/33) using" + "; key2task-using-by-get2image4epu: " + str(key2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
image2epu [key2task] = epu2image4xi[key2task]
message2print = "{(Step HD2/33) set" + "; info-of-image2epu-set-by-get2imageinfo4epu to: " + str(image2epu [key2task]) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step HZ/70) yielded" + "; key2task-yielded-by-get2image4epu: " + str(key2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
except:
image2epu = {}
message2print = "{(Step 1Z3/70) yielded" + "; image2epu-yielded-by-get2image4epu: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 33/33) returning" + "; image2epu-returning-by-get2imageinfo4epu: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 2D: {'WIDTH': 800, 'HEIGHT': 800}
# 3D: {'WIDTH': 800, 'DEPTH': 800, 'HEIGHT': 800}
# 2D ALL: {'CODE2ERROR': 0,
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 09:05:31 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'},
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'BUFFER': ...
# 3D ALL: {'PIPE': (, ),
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create3image4epu-failed ; time: 09:05:31 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create3image4epu',
# 'METHOD': 'create3image4epu'},
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'BUFFER': ....
# 'HEIGHT': 800,
# 'QUEUE': ,
# 'WIDTH': 800,
# 'DEPTH': 800,
# 'FLAGS': 0,
# 'CONTEXT': ...
return image2epu
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def get2supportedimageformats4epu(task4supportedimageformats2epu=None):
'''
gets supported image formats for epu
'''
global epu2image4xi
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "get2supportedimageformats4epu"
method2print = "get2supportedimageformats4epu"
message2print = "{(Step 0A/33) started" + "; get2supportedimageformats4epu-started: " + str(get2supportedimageformats4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 0B/33) passed" + "; task4supportedimageformats2epu-passed-to-get2supportedimageformats4epu: " + str(task4supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None; {'DIMENSION': 3}
if task4supportedimageformats2epu is None:
task4supportedimageformats2epu = {}
task4supportedimageformats2epu['DIMENSION'] = 2 # 2D image is the default
dimension2xi = 2
try:
keys2supportedimageformats = task4supportedimageformats2epu.keys()
if 'DIMENSION' in keys2supportedimageformats:
dimension2xi = task4supportedimageformats2epu['DIMENSION']
if ((dimension2xi <=0) or (dimension2xi > 2)):
dimension2xi = 2
else:
dimension2xi = 2
except:
pass
message2print = "{(Step 1A/33) using" + "; dimension2xi-using-by-dimension2xi: " + str(dimension2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 2; 3
supportedimageformats2epu = {}
try:
if epu2image4xi is None:
# -------------------------------------------------------------------------------------
# INITIALIZE
# -------------------------------------------------------------------------------------
image2epu = create2image4epu() # create epu2image4xi
message2print = "{(Step 1B/33) initialized" + "; image2epu-initialized-by-get2supportedimageformats4epu to: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
pass
# -------------------------------------------------------------------------------------
# SUPPORTED IMAGE FORMATS FOR EPU
# -------------------------------------------------------------------------------------
supportedimageformats2epu = epu2image4xi['FORMAT']
message2print = "{(Step 1E/33) got" + "; supportedimageformats2epu-got-by-get2supportedimageformats4epu: " + str(supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
except:
try:
# -------------------------------------------------------------------------------------
# INITIALIZE
# -------------------------------------------------------------------------------------
image2epu = create2image4epu()
message2print = "{(Step 1F1/33) initialized" + "; image2epu-initialized-by-get2supportedimageformats4epu to: " + str(image2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -------------------------------------------------------------------------------------
# SUPPORTED IMAGE FORMATS FOR EPU
# -------------------------------------------------------------------------------------
supportedimageformats2epu = epu2image4xi['FORMAT']
message2print = "{(Step 1H/33) got" + "; supportedimageformats2epu-got-by-get2supportedimageformats4epu: " + str(supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z/70) yielded" + "; supportedimageformats2epu-yielded-by-get2image4epu: " + str(supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 33/33) returning" + "; supportedimageformats2epu-returning-by-get2supportedimageformats4epu: " + str(supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 2: {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# 3: {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
return supportedimageformats2epu
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def wait2image4epu(task4wait2image=None):
'''
waits epu2image4epu
'''
global epu2image4xi
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "wait2image4epu"
method2print = "wait2image4epu"
message2print = "{(Step 1A1/33) started" + "; wait2image4epu-started: " + str(wait2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1A2/33) passed" + "; task4wait2image-passed-by-wait2image4epu to: " + str(task4wait2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
try:
if epu2image4xi is None:
# -------------------------------------------------------------------------------------
# INITIALIZE - KEEP SYSTEM RUNNING
# -------------------------------------------------------------------------------------
epu2image4xi = create2image4epu()
message2print = "{(Step 1B/33) created" + "; epu2image4xi-created-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -------------------------------------------------------------------------------------
# WAIT
# -------------------------------------------------------------------------------------
queue2image4epu = None
try:
queue2image4epu = epu2image4xi['QUEUE']
message2print = "{(Step 1C/33) got" + "; queue2image4epu-got-by-wait2image4epu to: " + str(queue2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z1/70) yielded" + "; epu2xi-yielded-by-wait2image4epu: " + str(epu2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
size2image4epu = 0
try:
size2image4epu = queue2image4epu.qsize()
message2print = "{(Step 1D/33) got" + "; size2image4epu-got-by-wait2image4epu to: " + str(size2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z2/70) yielded" + "; epu2xi-yielded-by-wait2image4epu: " + str(epu2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
empty2image4epu = True
try:
empty2image4epu= queue2image4epu.empty()
message2print = "{(Step 1E/33) got" + "; empty2image4epu-got-by-wait2image4epu to: " + str(empty2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z3/70) yielded" + "; empty2image4epu-yielded-by-wait2image4epu: " + str(empty2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
full2image4epu = False
try:
full2image4epu = queue2image4epu.full()
message2print = "{(Step 1F/33) got" + "; full2image4epu-got-by-wait2image4epu to: " + str(full2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z4/70) yielded" + "; full2image4epu-yielded-by-wait2image4epu: " + str(full2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 1G/33) finished" + "; epu2image4xi-finished-by-wait2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
# -------------------------------------------------------------------------------------
# USE THE EXISTING IMAGE FOR EPU
# -------------------------------------------------------------------------------------
message2print = "{(Step 1H/33) used" + "; epu2image4xi-used-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -------------------------------------------------------------------------------------
# WAIT
# -------------------------------------------------------------------------------------
queue2image4epu = None
try:
queue2image4epu = epu2image4xi['QUEUE']
message2print = "{(Step 1I/33) got" + "; queue2image4epu-got-by-wait2image4epu to: " + str(queue2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z5/70) yielded" + "; epu2xi-yielded-by-wait2image4epu: " + str(epu2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
if task4wait2image is None:
pass
else:
# -------------------------------------------------------------------------------------
# IMAGE GIVEN AS PARAMETER
# -------------------------------------------------------------------------------------
message2print = "{(Step 1J1/33) passed" + "; task4wait2image-passed-by-wait2image4epu to: " + str(task4wait2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
queue2task = {}
try:
queue2task = task4wait2image ['QUEUE']
message2print = "{(Step 1J2/33) set" + "; queue2task-set-by-wait2image4epu to: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z61/70) yielded" + "; queue2task-yielded-by-wait2image4epu: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
try:
if queue2task == queue2image4epu:
# -------------------------------------------------------------------------------------
# ACCEPTED - GIVEN QUEUE IS THE SAME
# -------------------------------------------------------------------------------------
message2print = "{(Step 1K/33) accepted" + "; queue2task-accepted-by-wait2image4epu: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
try:
message2print = "{(Step 1L/33) warned" + "; queue2task-warned-by-wait2image4epu: " + " ** " + str(queue2task) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1M/33) warned" + "; queue2image4epu-warned-by-wait2image4epu: " + " ** " + str(queue2image4epu) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
pass
except:
message2print = "{(Step 1Z62/70) yielded" + "; queue2task-yielded-by-wait2image4epu: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
size2queue4epu = 0
try:
size2queue4epu = queue2image4epu.qsize()
message2print = "{(Step 1N1/33) got" + "; size2queue4epu-got-by-wait2image4epu to: " + str(size2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
epu2image4xi ['SIZE2QUEUE'] = size2queue4epu
message2print = "{(Step 1N2/33) set" + "; size2queue4image-got-by-wait2image4epu to: " + str(epu2image4xi ['SIZE2QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z7/70) yielded" + "; size2queue4epu-yielded-by-wait2image4epu: " + str(size2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
empty2queue4epu = False
try:
empty2queue4epu = queue2image4epu.empty()
message2print = "{(Step 1O1/33) got" + "; empty2queue4epu-got-by-wait2image4epu to: " + str(empty2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
epu2image4xi ['EMPTY2QUEUE'] = empty2queue4epu
message2print = "{(Step 1O2/33) set" + "; empty2queue4image-got-by-wait2image4epu to: " + str(epu2image4xi ['EMPTY2QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z8/70) yielded" + "; empty2queue4epu-yielded-by-wait2image4epu: " + str(empty2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
full2queue4epu = False
try:
full2queue4epu = queue2image4epu.full()
message2print = "{(Step 1P1/33) got" + "; full2queue4epu-got-by-wait2image4epu to: " + str(full2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
epu2image4xi ['FULL2QUEUE'] = full2queue4epu
message2print = "{(Step 1P2/33) set" + "; full2queue4image-got-by-wait2image4epu to: " + str(epu2image4xi ['FULL2QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z9/70) yielded" + "; full2queue4epu-yielded-by-wait2image4epu: " + str(full2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
state2queue4epu = None
try:
state2queue4epu = queue2image4epu.__getstate__()
message2print = "{(Step 1P3/33) got" + "; state2queue4epu-got-by-wait2image4epu to: " + str(state2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
epu2image4xi ['STATE2QUEUE'] = state2queue4epu
message2print = "{(Step 1P4/33) set" + "; state2queue4image-set-by-wait2image4epu to: " + str(epu2image4xi ['STATE2QUEUE']) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z10/70) yielded" + "; state2queue4epu-yielded-by-wait2image4epu: " + str(state2queue4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 1Q/33) finished" + "; epu2image4xi-finished-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
try:
# -------------------------------------------------------------------------------------
# INITIALIZE
# -------------------------------------------------------------------------------------
epu2image4epu = create2image4epu()
message2print = "{(Step 1R/33) got" + "; epu2image4xi-got-by-wait2image4epu to: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -------------------------------------------------------------------------------------
# WAIT
# -------------------------------------------------------------------------------------
queue2image4epu = None
try:
queue2image4epu = epu2image4xi['QUEUE']
message2print = "{(Step 1S/33) got" + "; queue2image4epu-got-by-wait2image4epu to: " + str(queue2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z10/70) yielded" + "; queue2image4epu-yielded-by-wait2image4epu: " + str(queue2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
if task4wait2image is None:
pass
else:
# -------------------------------------------------------------------------------------
# IMAGE QUEUE GIVEN AS PARAMETER
# -------------------------------------------------------------------------------------
queue2task = None
try:
queue2task = task4wait2image ['QUEUE']
message2print = "{(Step 1T/33) passed" + "; queue2task-passed-by-wait2image4epu to: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
if queue2task == queue2image4epu:
# -------------------------------------------------------------------------------------
# ACCEPTED - GIVEN QUEUE IS THE SAME
# -------------------------------------------------------------------------------------
message2print = "{(Step 1U/33) accepted" + "; queue2task-accepted-by-wait2image4epu: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
else:
message2print = "{(Step 1X/33) warned" + "; queue2task-warned-by-wait2image4epu: " + " ** " + str(queue2task) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1Y1/33) warned" + "; queue2image4epu-warned-by-wait2image4epu: " + " ** " + str(queue2image4epu) + " ** " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z11/70) yielded" + "; queue2task-yielded-by-wait2image4epu: " + str(queue2task) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
size2image4epu = 0
try:
size2image4epu = queue2image4epu.qsize()
message2print = "{(Step 1Y2/33) got" + "; size2image4epu-got-by-wait2image4epu to: " + str(size2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z12/70) yielded" + "; size2image4epu-yielded-by-wait2image4epu: " + str(size2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
empty2image4epu = True
try:
empty2image4epu = queue2image4epu.empty()
message2print = "{(Step 1Y3/33) got" + "; empty2image4epu-got-by-wait2image4epu to: " + str(empty2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z13/70) yielded" + "; epu2xi-yielded-by-wait2image4epu: " + str(epu2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
full2image4epu = False
try:
full2image4epu= queue2image4epu.full()
message2print = "{(Step 1Y4/33) got" + "; full2image4epu-got-by-wait2image4epu to: " + str(full2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 1Z14/70) yielded" + "; full2image4epu-yielded-by-wait2image4epu: " + str(full2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 1Y5/33) finished" + "; epu2image4xi-finished-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
except:
epu2image4epu= {}
message2print = "{(Step 1Z15/70) yielded" + "; epu2image4xi-yielded-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 33/33) returning" + "; epu2image4xi-returning-by-wait2image4epu: " + str(epu2image4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8',
# 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': ...
return epu2image4xi
#
# =================================================================================================
#
# =================================================================================================
class EPU2Image4Xi(object):
'''
EPU2Image4Xi offers methods for EPU 2D images
'''
#
# ---------------------------------------------------------------------------------------------
# sharable class variables
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
# Public API of this class
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def __init__(self, task4imagecreate2epu = None):
'''
_init__ method initializes EPU2Image4Xi
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "__init__"
message2print = "{(Step 1A/33) started" + "; init-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 23:41:37 09/06/11 Pacific Daylight Time
message2print = "{(Step 1B/33) borning" + "; epu2image2xi-of-EPU2Image4Xi-borning: None" + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
message2print = "{(Step 1C/33) inheriting" + "; object-inheriting-by-epu2image2xi-of-EPU2Image4Xi: " + str(object) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1D/33) sharing" + "; classvariable2epu-sharing-by-epu2image2xi-of-EPU2Image4Xi: " + str(EPU2Image4Xi.classvariable2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 4
message2print = "{(Step 1E/33) passed" + "; task4imagecreate2epu-passed-to-init-of-EPU2Image4Xi: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4imagecreate2epu-passing-to-create2image4epu-by-init-of-EPU2Image4Xi: " + str(task4imagecreate2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
epu2image2xi = create2image4epu(task4imagecreate2epu)
message2print = "{(Step 2B/33) performed" + "; create2image4epu-performed-by-init-of-EPU2Image4Xi: " + str(create2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) activated" + "; epu2image2xi-of-EPU2Image4Xi-activated: " + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# { EPU2Image4Xi : __init__ ; (Step 3A/33) activated; epu2image2xi-of-EPU2Image4Xi-activated: ; time: 00:14:05 09/07/11 Pacific Daylight Time}
message2print = "{(Step 3B/33) inherited" + "; object-inherited-by-epu2image2xi-of-EPU2Image4Xi: " + str(object) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 3C/33) shared" + "; classvariable2epu-shared-by-epu2image2xi-of-EPU2Image4Xi: " + str(EPU2Image4Xi.classvariable2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 4
message2print = "{(Step 3D/33) returning" + "; init-of-EPU2Image4Xi-returning: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def create2image(self, task4image2create = None):
'''
create2image method creates 2D image objects of EPU2Image4Xi
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "create2image"
message2print = "{(Step 1A/33) started" + "; create2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4image2create-passed-to-create-of-EPU2Image4Xi: " + str(task4image2create) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4image2create-passing-to-create2image4epu-by-create2image-of-EPU2Image4Xi: " + str(task4image2create) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
epu2image2xi = create2image4epu(task4image2create)
message2print = "{(Step 2B/33) performed" + "; create2image4epu-performed-by-create2image-of-EPU2Image4Xi: " + str(create2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3/33) returning" + "; epu2image2xi-returning-by-create2image-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print) #
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-14B-15B-16B-17B-17D-18B-18C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-34H-35H-36B-37B-38B-',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 00:53:55 10/05/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'},
# 'WIDTH': 800 ...
return epu2image2xi
#
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def set2image(self, task4set2image = None):
'''
sets 2D image EPU objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "set2image"
message2print = "{(Step 1A/33) started" + "; set2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:02:22 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4set2image-passed-to-set2image-of-EPU2Image4Xi: " + str(task4set2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'QUEUE': ,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4set2image-passing-to-set2image4epu-by-set2image-of-EPU2Image4Xi: " + str(task4set2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'QUEUE': ,
# 'CONTEXT': {'COUNT2REFERENCE': 0 ...
epu2image2xi = set2image4epu(task4set2image)
message2print = "{(Step 2B/33) performed" + "; set2image4epu-performed-by-set2image-of-EPU2Image4Xi: " + str(set2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; epu2image2xi-returning-by-set2image-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' 23B-24B-25B-26B-27B-28B-',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 01:02:22 09/07/11 Pacific Daylight Time}', 'CLASS': 'create2image4epu', 'METHOD': 'create2image4epu'},
# 'WIDTH': 800,
# 'BUFFER': {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 01:02:22 09/07/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0 ...
return epu2image2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def get2imageinfo(self, task4getinfo2image=None):
'''
get2imageinfo method gets 2D objects of EPU2Image4Xi
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "get2imageinfo"
message2print = "{(Step 1A/33) started" + "; get2imageinfo-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
epu2image2xi = get2imageinfo4epu(task4getinfo2image)
message2print = "{(Step 2A/33) returning" + "; epu2image2xi-returning-by-get2imageinfo-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-14B-15B-16B-17B-17D-18B-18C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-34H-35H-36B-37B-38B-',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 00:14:05 09/07/11 Pacific Daylight Time}', 'CLASS': 'create2image4epu', 'METHOD': 'create2image4epu'},
# 'WIDTH': 800,
# 'BUFFER': {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4epu-failed ; time: 00:14:05 09/07/11 Pacific Daylight Time}',
# 'CLASS': 'create2buffer4epu',
# 'METHOD': 'create2buffer4epu'},
# 'FUNCTION2CALLBACK': ,
# 'POINTER2BUFFER': ,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0, ...
# or when only two elemets required
# {'WIDTH': 800, 'HEIGHT': 800}
return epu2image2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def get2supportedimageformats(self):
'''
get2supportedimageformats method gets supported imageformats by objects of EPU2Image4Xi
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "get2supportedimageformats"
message2print = "{(Step 1A/33) started" + "; get2supportedimageformats-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:43:00 09/07/11 Pacific Daylight Time
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
supportedimageformats2epu = get2supportedimageformats4epu()
message2print = "{(Step 2A/33) returning" + "; supportedimageformats2epu-returning-by-get2imageinfo-of-EPU2Image4Xi: " + str(supportedimageformats2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
return supportedimageformats2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def read2image(self, task4read2image = None):
'''
reads EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "read2image"
message2print = "{(Step 1A/33) started" + "; read2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:20:02 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4read2image-passed-to-read2image-of-EPU2Image4Xi: " + str(task4read2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4read2image-passing-to-read2image4epu-by-read2image-of-EPU2Image4Xi: " + str(task4read2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4readimage2epu = read2image4epu(task4read2image)
message2print = "{(Step 2B/33) performed" + "; read2image4epu-performed-by-read2image-of-EPU2Image4Xi: " + str(read2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4readimage2epu-returning-by-read2image-of-EPU2Image4Xi: " + str(response4readimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 00:20:02 10/05/11 Pacific Daylight Time}
return response4readimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def map2image(self, task4map2image = None):
'''
maps EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "map2image"
message2print = "{(Step 1A/33) started" + "; map2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:28:44 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4map2image-passed-to-map2image-of-EPU2Image4Xi: " + str(task4map2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4map2image-passing-to-map2image4epu-by-map2image-of-EPU2Image4Xi: " + str(task4map2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4mapimage2epu = map2image4epu(task4map2image)
message2print = "{(Step 2B/33) performed" + "; map2image4epu-performed-by-map2image-of-EPU2Image4Xi: " + str(map2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4mapimage2epu-returning-by-map2image-of-EPU2Image4Xi: " + str(response4mapimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return response4mapimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def release2image(self, task4release2image = None):
'''
releases EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "release2image"
message2print = "{(Step 1A/33) started" + "; release2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
message2print = "{(Step 1B/33) passed" + "; task4release2image-passed-to-release2image-of-EPU2Image4Xi: " + str(task4release2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4release2image-passing-to-release2image4epu-by-release2image-of-EPU2Image4Xi: " + str(task4release2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
epu2image2xi = release2image4epu(task4release2image)
message2print = "{(Step 2B/33) performed" + "; release2image4epu-performed-by-release2image-of-EPU2Image4Xi: " + str(release2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; epu2image2xi-returning-by-release2image-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
return epu2image2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def retain2image(self, task4retain2image = None):
'''
retains EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "retain2image"
message2print = "{(Step 1A/33) started" + "; retain2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4retain-passed-to-retain2image-of-EPU2Image4Xi: " + str(task4retain2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 1}
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4retain-passing-to-retain2image4epu-by-retain-of-EPU2Image4Xi: " + str(task4retain2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'COUNT2REFERENCE': 1}
epu2image2xi = retain2image4epu(task4retain2image)
message2print = "{(Step 2B/33) performed" + "; retain2image4epu-performed-by-retain2image-of-EPU2Image4Xi: " + str(retain2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; epu2image2xi-returning-by-retain2image-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'CODE2ERROR': 0,
# 'ACK2RETURN': ' 1D-',
# 'ROWPITCH': 800,
# 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2image4epu-failed ; time: 00:14:05 09/07/11 Pacific Daylight Time}',
# 'CLASS': 'create2image4epu',
# 'METHOD': 'create2image4epu'},
# 'WIDTH': 800,
# 'BUFFER': {'CODE2ERROR': 0,
# ...
# 'COUNT2REFERENCE': 1,
# 'FLAGS': 0,
# 'CONTEXT': {'COUNT2REFERENCE': 0 ...
return epu2image2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def wait2image(self, task4wait2image = None):
'''
waits EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "wait2image"
message2print = "{(Step 1A/33) started" + "; wait2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4wait2image-passed-to-wait2image-of-EPU2Image4Xi: " + str(task4wait2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4wait-passing-to-wait2image4epu-by-wait2image-of-EPU2Image4Xi: " + str(task4wait2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
epu2image2xi = wait2image4epu(task4wait2image)
message2print = "{(Step 2B/33) performed" + "; wait2image4epu-performed-by-wait2image-of-EPU2Image4Xi: " + str(wait2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# semaphore and lock analysis by multiprocessing4xi
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; epu2image2xi-returning-by-wait2image-of-EPU2Image4Xi: " + str(epu2image2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'SIZE2QUEUE': 2147483646,
# 'FORMAT': {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'},
# 'QUEUE': ,
# 'WIDTH': 800,
# 'CONTEXT': ...
return epu2image2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def write2image(self, task4write2image = None):
'''
writes EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "write2image"
message2print = "{(Step 1A/33) started" + "; write2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 02:45:31 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4write2image-passed-to-write2image-of-EPU2Image4Xi: " + str(task4write2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4write2image-passing-to-write2image4epu-by-write2image-of-EPU2Image4Xi: " + str(task4write2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4writeimage2epu = write2image4epu(task4write2image)
message2print = "{(Step 2B/33) performed" + "; write2image4epu-performed-by-write2image-of-EPU2Image4Xi: " + str(write2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4writeimage2epu-returning-by-write2image-of-EPU2Image4Xi: " + str(response4writeimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 02:45:31 10/05/11 Pacific Daylight Time}
return response4writeimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def copy2image(self, task4copy2image = None):
'''
copies EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "copy2image"
message2print = "{(Step 1A/33) started" + "; copy2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:28:44 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4copy2image-passed-to-copy2image-of-EPU2Image4Xi: " + str(task4copy2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4copy2image-passing-to-copy2image4epu-by-copy2image-of-EPU2Image4Xi: " + str(task4copy2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4copyimage2epu = copy2image4epu(task4copy2image)
message2print = "{(Step 2B/33) performed" + "; copy2image4epu-performed-by-copy2image-of-EPU2Image4Xi: " + str(copy2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4copyimage2epu-returning-by-copy2image-of-EPU2Image4Xi: " + str(response4copyimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return response4copyimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def copy2imagetobuffer(self, task4copy2imagetobuffer = None):
'''
copies 2D images to buffer
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "copy2imagetobuffer"
message2print = "{(Step 1A/33) started" + "; copy2imagetobuffer-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:28:44 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4copy2imagetobuffer-passed-to-copy2imagetobuffer-of-EPU2Image4Xi: " + str(task4copy2imagetobuffer) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4copy2imagetobuffer-passing-to-copy2imagetobuffer4epu-by-copy2imagetobuffer-of-EPU2Image4Xi: " + str(task4copy2imagetobuffer) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4copyimage2epu = copy2imagetobuffer4epu(task4copy2imagetobuffer)
message2print = "{(Step 2B/33) performed" + "; copy2imagetobuffer4epu-performed-by-copy2imagetobuffer-of-EPU2Image4Xi: " + str(copy2imagetobuffer4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4copyimage2epu-returning-by-copy2imagetobuffer-of-EPU2Image4Xi: " + str(response4copyimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return response4copyimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def copy2buffertoimage(self, task4copy2buffertoimage = None):
'''
copies 2D images to buffer
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "copy2buffertoimage"
message2print = "{(Step 1A/33) started" + "; copy2buffertoimage-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:28:44 10/05/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4copy2buffertoimage-passed-to-copy2buffertoimage-of-EPU2Image4Xi: " + str(task4copy2buffertoimage) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4copy2buffertoimage-passing-to-copy2buffertoimage4epu-by-copy2buffertoimage-of-EPU2Image4Xi: " + str(task4copy2buffertoimage) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
response4copyimage2epu = copy2buffertoimage4epu(task4copy2buffertoimage)
message2print = "{(Step 2B/33) performed" + "; copy2buffertoimage4epu-performed-by-copy2buffertoimage-of-EPU2Image4Xi: " + str(copy2buffertoimage4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; response4copyimage2epu-returning-by-copy2buffertoimage-of-EPU2Image4Xi: " + str(response4copyimage2epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }; time: 01:28:44 10/05/11 Pacific Daylight Time}
return response4copyimage2epu
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def trace2image(self, task4trace2image = None):
'''
traces EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "trace2image"
message2print = "{(Step 1A/33) started" + "; trace2image-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4trace2image-passed-to-trace-of-EPU2Image4Xi: " + str(task4trace2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4trace2image-passing-to-trace2image4epu-by-trace2image-of-EPU2Image4Xi: " + str(task4trace2image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
trace2xi = trace2image4epu(task4trace2image)
message2print = "{(Step 2B/33) performed" + "; trace2image4epu-performed-by-trace2image-of-EPU2Image4Xi: " + str(trace2image4epu) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; trace2xi-returning-by-trace2image-of-EPU2Image4Xi: " + str(trace2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'MESSAGE': '{(Step 2Z0/33) failed; trace2image4epu-failed {}; time: 01:05:20 09/08/11 Pacific Daylight Time}',
# 'CLASS': 'trace2image4epu',
# 'METHOD': 'trace2image4epu'}; time: 01:05:20 09/08/11 Pacific Daylight Time}
return trace2xi
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def set2imagecallback(self, task4set2imagecallback = None):
'''
set2imagecallback of EPU2Image4Xi objects
'''
# -----------------------------------------------------------------------------------------
# (Step 1/33)
# -----------------------------------------------------------------------------------------
class2print = "EPU2Image4Xi"
method2print = "set2imagecallback"
message2print = "{(Step 1A/33) started" + "; set2imagecallback-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 00:14:05 09/07/11 Pacific Daylight Time
message2print = "{(Step 1B/33) passed" + "; task4set2imagecallback-passed-to-set2imagecallback-of-EPU2Image4Xi: " + str(task4set2imagecallback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
# -----------------------------------------------------------------------------------------
# (Step 2/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) passing" + "; task4set2imagecallback-passing-to-set2imagecallback -by-set2imagecallback-of-EPU2Image4Xi: " + str(task4set2imagecallback) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# None
callback2epu4image = {}
try:
callback2epu4image = set2imagecallback4epu (task4set2imagecallback)
message2print = "{(Step 2B/33) callback2epu4image" + "; callback2epu4image-set-by-set2imagecallback-of-EPU2Image4Xi to: " + str(callback2epu4image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
except:
message2print = "{(Step 4A/33) failed" + "; callback2epu4image-failed-by-set2imagecallback-of-EPU2Image4Xi: " + str(callback2epu4image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# -----------------------------------------------------------------------------------------
# (Step 3/33)
# -----------------------------------------------------------------------------------------
message2print = "{(Step 3A/33) returning" + "; callback2epu4image-returning-by-set2imagecallback-of-EPU2Image4Xi: " + str(callback2epu4image) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
return callback2epu4image
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def sense(self):
'''
method sense: senses EPU2Image4Xi class objects
'''
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
class2print = 'EPU2Image4Xi'
method2print = 'sense'
message2print = "{(Step 1A/33) started" + "; sense-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:02:22 09/07/11 Pacific Daylight Time
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) sensing" + "; EPU2Image4Xi-sensing-by-sense-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# get sensed knowledge for this object
# -----------------------------------------------------------------------------------------
kb2xi = sense_object4xi(self)
message2print = "{(Step 3A/33) got" + "; kb2xi-got-by-sense-of-EPU2Image4Xi: " + str(kb2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'object': }
# -----------------------------------------------------------------------------------------
# add knowledge specific to this object
# format example: kb2xi['time2xi'] = time4xi() #adding time
# -----------------------------------------------------------------------------------------
try:
kb2xi['classvariable2epu-of-EPU2Image4Xi'] = EPU2Image4Xi.classvariable2epu
except:
message2print = "{(Step 4A/33) yielded" + "; kb2xi-yielded-by-sense-of-EPU2Image4Xi: " + str(kb2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 5A/33) sensed" + "; EPU2Image4Xi-sensed-by-sense-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 6A/33) returning" + "; kb2xi-returning-by-sense-of-EPU2Image4Xi: " + str(kb2xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'object': , 'classvariable2epu-of-EPU2Image4Xi': 4}
return kb2xi
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def reason(self):
'''
method reason: reasons EPU2Image4Xi class objects
'''
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
class2print = 'EPU2Image4Xi'
method2print = 'reason'
message2print = "{(Step 1A/33) started" + "; reason-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:02:22 09/07/11 Pacific Daylight Time
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) reasoning" + "; EPU2Image4Xi-reasoning-by-reason-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# get reasoned knowledge for this object
# -----------------------------------------------------------------------------------------
kb4xi = reason_object4xi(self)
message2print = "{(Step 3A/33) got" + "; kb4xi-got-by-reason-of-EPU2Image4Xi: " + str(kb4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'object-reason-object4xi': }
# -----------------------------------------------------------------------------------------
# add knowledge specific to this object
# format example: kb4xi['time2xi'] = time4xi() #adding time
# -----------------------------------------------------------------------------------------
try:
kb4xi['time-reason-of-EPU2Image4Xi'] = time4xi() #adding time
except:
message2print = "{(Step 4Z/33) yielded" + "; kb4xi-yielded-by-reason-of-EPU2Image4Xi: " + str(kb4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 5A/33) reasoned" + "; EPU2Image4Xi-reasoned-by-reason-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 6A/33) returning" + "; kb4xi-returning-by-reason-of-EPU2Image4Xi: " + str(kb4xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'object-reason-object4xi': , 'time-reason-of-EPU2Image4Xi': '01:02:22 09/07/11 Pacific Daylight Time'}
return kb4xi
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
def ace(self):
'''
method ace: aces EPU2Image4Xi class objects
'''
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
class2print = 'EPU2Image4Xi'
method2print = 'ace'
message2print = "{(Step 1A/33) started" + "; ace-of-EPU2Image4Xi-started: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# 01:02:22 09/07/11 Pacific Daylight Time
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 2A/33) acing" + "; EPU2Image4Xi-acing-by-ace-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
# get aced knowledge for this object
# -----------------------------------------------------------------------------------------
kb8xi = ace_object4xi(self)
message2print = "{(Step 3A/33) got" + "; kb8xi-got-by-ace-of-EPU2Image4Xi: " + str(kb8xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'object8xi': }
# -----------------------------------------------------------------------------------------
# add knowledge specific to this object
# format example: kb8xi['time2xi'] = time4xi() #adding time
# -----------------------------------------------------------------------------------------
try:
kb8xi['cores-of-EPU2Image4Xi'] = EPU2Image4Xi.classvariable2epu
except:
message2print = "{(Step 4A/33) yielded" + "; kb8xi-yielded-by-ace-of-EPU2Image4Xi: " + str(kb8xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
message2print = "{(Step 5A/33) aced" + "; EPU2Image4Xi-aced-by-ace-of-EPU2Image4Xi: " + str(EPU2Image4Xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
message2print = "{(Step 6A/33) returning" + "; kb8xi-returning-by-ace-of-EPU2Image4Xi: " + str(kb8xi) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
# {'cores-of-EPU2Image4Xi': 4, 'object8xi': }
return kb8xi
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
#
#
#
# -------------------------------------------------------------------------------------------------
# Recorded History
# -------------------------------------------------------------------------------------------------
#
#
# -------------------------------------------------------------------------------------------------
# to-be-done
# -------------------------------------------------------------------------------------------------
#
#
# -------------------------------------------------------------------------------------------------
# Legal Notice
# -------------------------------------------------------------------------------------------------
#
#