def setUpClass(cls): super(TestGaussian, cls).setUpClass() cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) cls.kernels = {"preprocess": 8, "gaussian": 512} device = cls.ctx.devices[0] device_id = device.platform.get_devices().index(device) platform_id = pyopencl.get_platforms().index(device.platform) maxwg = ocl.platforms[platform_id].devices[device_id].max_work_group_size # logger.warning("max_work_group_size: %s on (%s, %s)", maxwg, platform_id, device_id) for kernel in list(cls.kernels.keys()): if cls.kernels[kernel] < maxwg: logger.warning("%s Limiting workgroup size to %s", kernel, maxwg) cls.kernels[kernel] = maxwg cls.max_wg = maxwg for kernel in list(cls.kernels.keys()): kernel_src = get_opencl_code(os.path.join("sift", kernel)) program = pyopencl.Program(cls.ctx, kernel_src).build("-D WORKGROUP=%s" % cls.kernels[kernel]) cls.kernels[kernel] = program
def setUpClass(cls): super(TestGaussian, cls).setUpClass() cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue( cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) cls.kernels = {"preprocess": 8, "gaussian": 512} device = cls.ctx.devices[0] device_id = device.platform.get_devices().index(device) platform_id = pyopencl.get_platforms().index(device.platform) maxwg = ocl.platforms[platform_id].devices[ device_id].max_work_group_size # logger.warning("max_work_group_size: %s on (%s, %s)", maxwg, platform_id, device_id) for kernel in list(cls.kernels.keys()): if cls.kernels[kernel] < maxwg: logger.warning("%s Limiting workgroup size to %s", kernel, maxwg) cls.kernels[kernel] = maxwg cls.max_wg = maxwg for kernel in list(cls.kernels.keys()): kernel_src = get_opencl_code(os.path.join("sift", kernel)) program = pyopencl.Program(cls.ctx, kernel_src).build( "-D WORKGROUP=%s" % cls.kernels[kernel]) cls.kernels[kernel] = program
def setUpClass(cls): super(TestMatching, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx)
def setUpClass(cls): super(TestAddition, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) import pylab else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) cls.max_valid_wg = 0
def setUpClass(cls): super(TestMatching, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue( cls.ctx, properties=pyopencl.command_queue_properties. PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx)
def setUpClass(cls): super(TestAlgebra, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) device = cls.ctx.devices[0] device_id = device.platform.get_devices().index(device) platform_id = pyopencl.get_platforms().index(device.platform) cls.maxwg = ocl.platforms[platform_id].devices[device_id].max_work_group_size
def setUpClass(cls): super(TestImage, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) device = cls.ctx.devices[0] device_id = device.platform.get_devices().index(device) platform_id = pyopencl.get_platforms().index(device.platform) cls.maxwg = ocl.platforms[platform_id].devices[device_id].max_work_group_size
def setUpClass(cls): super(TestReduction, cls).setUpClass() if ocl: cls.ctx = ocl.create_context() if logger.getEffectiveLevel() <= logging.INFO: cls.PROFILE = True cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE) else: cls.PROFILE = False cls.queue = pyopencl.CommandQueue(cls.ctx) device = cls.ctx.devices[0] device_id = device.platform.get_devices().index(device) platform_id = pyopencl.get_platforms().index(device.platform) cls.maxwg = ocl.platforms[platform_id].devices[device_id].max_work_group_size # logger.warning("max_work_group_size: %s on (%s, %s)", cls.maxwg, platform_id, device_id) kernel_src = get_opencl_code(os.path.join("sift", "reductions")) cls.program = pyopencl.Program(cls.ctx, kernel_src).build(options="")
from ..alignFFT import alignFFT from ..alignSimple import alignMin from ..alignSimple import alignMax from ..alignSimple import alignCentroid from ..alignSimple import alignGaussMax from ..types import transformationType from . import helper_teststack from ...utils.cli import getLogger logger = getLogger(__name__, __file__) logger.setLevel(logging.DEBUG) from silx.opencl import ocl if ocl: has_ocl_device = ocl.create_context() is not None else: has_ocl_device = False class test_align(unittest.TestCase): def compare_relativecof(self, cofs, cofrel, msg=None): for i in range(1, cofs.shape[0]): cofrelcalc = np.dot(np.linalg.inv(cofs[i - 1, ...]), cofs[i, ...]) np.testing.assert_almost_equal(cofrelcalc, cofrel, decimal=1, err_msg=msg) def assertAligned(self, outputstack, stackdim): for stack in outputstack:
def process(options): """Perform actually the processing :param options: The argument parsed by agrparse. :return: EXIT_SUCCESS or EXIT_FAILURE """ if options.verbose: pb = None else: pb = ProgressBar("Sparsification", 100, 30) logger.debug("Count the number of frames") if pb: pb.update(0, message="Count the number of frames") dense = [fabio.open(f) for f in options.images] nframes = sum([f.nframes for f in dense]) logger.debug("Initialize the geometry") if pb: pb.update(0, message="Initialize the geometry", max_value=nframes) ai = load(options.poni) if options.mask is not None: mask = fabio.open(options.mask).data ai.detector.mask = mask else: mask = ai.detector.mask shape = dense[0].shape if options.radial_range is not None: rrange = [ i * numpy.mean(ai.detector.pixel1, ai.detector.pixel2) for i in options.radial_range ] else: rrange = None integrator = ai.setup_CSR(shape, options.bins, mask=mask, pos0_range=rrange, unit=R_M, split="no", scale=False) logger.debug("Initialize the OpenCL device") if pb: pb.update(0, message="Initialize the OpenCL device") if options.device is not None: ctx = ocl.create_context( platformid=options.device[0], deviceid=options.device[1], ) else: ctx = ocl.create_context(devicetype=options.device_type) logger.debug("Initialize the sparsificator") pf = OCL_PeakFinder(integrator.lut, image_size=shape[0] * shape[1], empty=options.dummy, unit=R_M, bin_centers=integrator.bin_centers, radius=ai._cached_array["r_center"], mask=mask, ctx=ctx) logger.debug("Start sparsification") frames = [] cnt = 0 parameters = { "dummy": options.dummy, "delta_dummy": options.delta_dummy, "safe": False, "error_model": options.error_model, "cutoff_clip": options.cutoff_clip, "cycle": options.cycle, "noise": options.noise, "cutoff_pick": options.cutoff_pick, "radial_range": rrange } for fabioimage in dense: for frame in fabioimage: current = pf.sparsify(frame.data, **parameters) frames.append(current) if pb: pb.update(cnt, message="%s: %i pixels" % (os.path.basename( fabioimage.filename), current.intensity.size)) else: print("%s frame #%d, found %d intense pixels" % (fabioimage.filename, fabioimage.currentframe, current.intensity.size)) cnt += 1 logger.debug("Save data") if pb: pb.update(nframes, message="Saving: " + options.output) else: print("Saving: " + options.output) save_sparse(options.output, frames, beamline=options.beamline, ai=ai, source=options.images if options.save_source else None) return EXIT_SUCCESS