Exemple #1
0
    def __init__(self, context, devices, dImg):
        self.context = context
        self.queue = cl.CommandQueue(context, properties=cl.command_queue_properties.PROFILING_ENABLE)

        self.dim = dImg.dim

        options = [
            '-D IMAGEW='+str(self.dim[0]),
            '-D IMAGEH='+str(self.dim[1]),
            ]

        self.dImg = dImg
        self.dFg = Buffer2D(context, cl.mem_flags.READ_WRITE, self.dim, np.uint32)
        self.dBg = Buffer2D(context, cl.mem_flags.READ_WRITE, self.dim, np.uint32)
        self.dLcv = Buffer2D(context, cl.mem_flags.READ_WRITE, self.dim, np.float32)
        self.dAlpha = Buffer2D(context, cl.mem_flags.READ_WRITE, self.dim, np.float32)

        filename = os.path.join(os.path.dirname(__file__), 'sharedmatting.cl')
        program = createProgram(context, devices, options, filename)

        self.kernGather = cl.Kernel(program, 'gather')
        self.kernLcv = cl.Kernel(program, 'local_color_variation')
        self.kernRefine = cl.Kernel(program, 'refine')
        self.kernProcessTrimap = cl.Kernel(program, 'process_trimap')
        self.trimapFilter = cl.Kernel(program, 'trimap_filter')

        gWorksize = roundUp(self.dim, SharedMatting.lw)
        args = [
            self.dImg,
            self.dLcv,
            self.dAlpha
        ]
        self.kernLcv(self.queue, gWorksize, SharedMatting.lw, *args)
Exemple #2
0
    def __init__(self, context, devices, capacity):
        self.context = context

        if PROFILE_GPU == True:
            self.queue = cl.CommandQueue(context, properties=cl.command_queue_properties.PROFILING_ENABLE)
        else:
            self.queue = cl.CommandQueue(context)

        filename = os.path.join(os.path.dirname(__file__), "prefixsum.cl")
        program = createProgram(context, devices, [], filename)

        self.kernScan_pad_to_pow2 = cl.Kernel(program, "scan_pad_to_pow2")
        self.kernScan_subarrays = cl.Kernel(program, "scan_subarrays")
        self.kernScan_inc_subarrays = cl.Kernel(program, "scan_inc_subarrays")

        self.lw = (LEN_WORKGROUP,)

        self.capacity = roundUp(capacity, ELEMENTS_PER_WORKGROUP)

        self.d_parts = []

        len = self.capacity / ELEMENTS_PER_WORKGROUP

        while len > 0:
            self.d_parts.append(cl.Buffer(context, cl.mem_flags.READ_WRITE, szInt * len))

            len = len / ELEMENTS_PER_WORKGROUP

        self.elapsed = 0
Exemple #3
0
    def __init__(self, shape, parent=None):
        super(CLCanvas, self).__init__(parent)

        self.w = 0

        self.pbo = None
        self.tex = None

        self.width = shape[0]
        self.height = shape[1]
        self.shape = shape

        self.zoom = 1.0
        self.transX = 0
        self.transY = 1
        self.flag = 0

        self.viewport = None

        self.resize(self.zoom * self.width, self.zoom * self.height)

        self.initializeGL()
        self.initCL()

        self.installEventFilter(self)

        self.fbo = glGenFramebuffers(1)
        self.rbos = glGenRenderbuffers(2)
        self.rbosCL = [None, None]
        for i in [0, 1]:
            glBindRenderbuffer(GL_RENDERBUFFER, self.rbos[i])
            glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, self.width,
                self.height)
            self.rbosCL[i] = cl.GLRenderBuffer(self.context, cm.READ_WRITE,
                int(self.rbos[i]))

        self.rboRead = 0
        self.rboWrite = 1

        self.buffers = {}

        self.layers = []

        self.devices = self.context.get_info(cl.context_info.DEVICES)
        self.queue = cl.CommandQueue(self.context,
            properties=cl.command_queue_properties.PROFILING_ENABLE)

        filename = os.path.join(os.path.dirname(__file__), 'clcanvas.cl')
        program = createProgram(self.context, self.devices, [], filename)

        self.kernBlendImgf = cl.Kernel(program, 'blend_imgf')
        self.kernBlendBufui = cl.Kernel(program, 'blend_bufui')
        self.kernBlendImgui = cl.Kernel(program, 'blend_imgui')

        self.kernFlip = cl.Kernel(program, 'flip')

        self.queue.finish()
        glFinish()
Exemple #4
0
    def __init__(self, context, range, hues=None, sats=None, vals=None):
        self.context = context

        devices = context.get_info(cl.context_info.DEVICES)

        filename = os.path.join(os.path.dirname(__file__), 'colorize.cl')
        program = createProgram(context, devices, [], filename)

        self.kern_ui8 = cl.Kernel(program, 'colorize_ui8')
        self.kern_ui = cl.Kernel(program, 'colorize_ui32')
        self.kern_i = cl.Kernel(program, 'colorize_i32')
        self.kern_f = cl.Kernel(program, 'colorize_f32')

        self.format = format
        self.range = range
        self.hues = hues if hues != None else Colorize.HUES.STANDARD
        self.vals = vals if vals != None else (1, 1)
        self.sats = sats if sats != None else (1, 1)
Exemple #5
0
    def __init__(self, context, devices, d_img, d_labels):
        Brush.__init__(self, context, devices, d_labels)

        self.context = context
        self.queue = cl.CommandQueue(context,
            properties=cl.command_queue_properties.PROFILING_ENABLE)

        nComponentsFg = 4
        nComponentsBg = 4
        self.nDim = 3

        self.dim = d_img.dim

        filename = os.path.join(os.path.dirname(__file__), 'quick.cl')
        program = createProgram(context, context.devices, [], filename)
        #        self.kernSampleBg = cl.Kernel(program, 'sampleBg')
        self.kern_get_samples = cl.Kernel(program, 'get_samples')

        self.lWorksize = (16, 16)
        self.gWorksize = roundUp(self.dim, self.lWorksize)

        nSamples = 4 * (self.gWorksize[0] / self.lWorksize[0]) * (
            self.gWorksize[1] / self.lWorksize[1])

        #		self.gmmFg_cpu = mixture.GMM(4)

        self.gmmFg = GMM(context, 65, nComponentsFg, 10240)
        self.gmmBg = GMM(context, 65, nComponentsBg, nSamples)

        self.hScore = np.empty(self.dim, np.float32)
        self.hSampleFg = np.empty((10240, ), np.uint32)
        self.hSampleBg = np.empty((12000, ), np.uint32)
        self.hA = np.empty((max(nComponentsFg, nComponentsBg), 8), np.float32)

        self.d_img = d_img

        cm = cl.mem_flags
        self.dSampleFg = cl.Buffer(context, cm.READ_WRITE, size=4 * 10240)
        self.dSampleBg = cl.Buffer(context, cm.READ_WRITE, size=4 * 12000)
        self.dA = cl.Buffer(context, cm.READ_ONLY | cm.COPY_HOST_PTR, hostbuf=self.hA)
        self.dScoreFg = Buffer2D(context, cm.READ_WRITE, self.dim, np.float32)
        self.dScoreBg = Buffer2D(context, cm.READ_WRITE, self.dim, np.float32)

        #self.points = Set()

        self.capPoints = 200 * 200 * 300 #brush radius 200, stroke length 300
        self.points = np.empty((self.capPoints), np.uint32)

        #		self.colorize = Colorize.Colorize(clContext, clContext.devices)

        #        self.hTriFlat = self.hTri.reshape(-1)

        #        self.probBg(1200)

        self.h_img = np.empty(self.dim, np.uint32)
        self.h_img = self.h_img.ravel()
        cl.enqueue_copy(self.queue, self.h_img, self.d_img, origin=(0, 0), region=self.dim).wait()

        self.samples_bg_idx = np.random.randint(0, self.dim[0] * self.dim[1], 12000)
        self.hSampleBg = self.h_img[self.samples_bg_idx]

        cl.enqueue_copy(self.queue, self.dSampleBg, self.hSampleBg).wait()

        w,m,c = self.gmmBg.fit(self.dSampleBg, 300, retParams=True)

        print w
        print m
        print c

        self.gmmBg.score(self.d_img, self.dScoreBg)

        pass
Exemple #6
0
    def __init__(self, context, devices, img, neighbourhood=NEIGHBOURHOOD.VON_NEUMANN, weight=None):
        self.context = context
        self.queue = cl.CommandQueue(context, properties=cl.command_queue_properties.PROFILING_ENABLE)

        if weight == None:
            weight = GrowCut.WEIGHT_DEFAULT

        if isinstance(img, cl.Image):
            self.dImg = img

            width = img.get_image_info(cl.image_info.WIDTH)
            height = img.get_image_info(cl.image_info.HEIGHT)

            dim = (width, height)
        else:
            raise NotImplementedError('Not implemented for {0}'.format(type(
                img)))

        self.tilelist = IncrementalTileList(context, devices, dim, (TILEW,
                                                                    TILEH))
        self.hHasConverged = np.empty((1,), np.int32)
        self.hHasConverged[0] = False

        self.dLabelsIn = Buffer2D(context, cm.READ_WRITE, dim, np.uint8)
        self.dLabelsOut = Buffer2D(context, cm.READ_WRITE, dim, np.uint8)
        self.dStrengthIn = Buffer2D(context, cm.READ_WRITE, dim, np.float32)
        self.dStrengthOut = Buffer2D(context, cm.READ_WRITE, dim, np.float32)
        self.dHasConverged = cl.Buffer(context, cm.READ_WRITE | cm.COPY_HOST_PTR, hostbuf=self.hHasConverged)

        self.args = [
            self.tilelist.d_list,
            self.dLabelsIn,
            self.dLabelsOut,
            self.dStrengthIn,
            self.dStrengthOut,
            self.dHasConverged,
            np.int32(self.tilelist.iteration),
            self.tilelist.d_tiles,
            cl.LocalMemory(szInt * 9),
            cl.LocalMemory(szInt * (TILEW + 2) * (TILEH + 2)),
            cl.LocalMemory(szFloat * (TILEW + 2) * (TILEH + 2)),
            #			cl.LocalMemory(4*szFloat*(TILEW+2)*(TILEH+2)),
            self.dImg,
            cl.Sampler(context, False, cl.addressing_mode.NONE, cl.filter_mode.NEAREST)
        ]

        self.gWorksize = roundUp(dim, self.lw)
        self.gWorksizeTiles16 = roundUp(dim, self.lWorksizeTiles16)

        options = [
            '-D TILESW=' + str(self.tilelist.dim[0]),
            '-D TILESH=' + str(self.tilelist.dim[1]),
            '-D IMAGEW=' + str(dim[0]),
            '-D IMAGEH=' + str(dim[1]),
            '-D TILEW=' + str(TILEW),
            '-D TILEH=' + str(TILEH),
            '-D G_NORM(X)=' + weight
        ]

        filename = os.path.join(os.path.dirname(__file__), 'growcut.cl')
        program = createProgram(context, devices, options, filename)

        if neighbourhood == GrowCut.NEIGHBOURHOOD.VON_NEUMANN:
            self.kernEvolve = cl.Kernel(program, 'evolveVonNeumann')
        elif neighbourhood == GrowCut.NEIGHBOURHOOD.MOORE:
            self.kernEvolve = cl.Kernel(program, 'evolveMoore')

        self.kernLabel = cl.Kernel(program, 'label')

        self.isComplete = False