Exemple #1
0
    def matlabFindTargets(self):
        pymat.put(self.handle, 'focus', [])
        pymat.put(self.handle, 'acquisition', [])

        d, f = os.path.split(self.settings['module path'])

        if d:
            pymat.eval(self.handle, 'path(path, \'%s\')' % d)

        if not f[:-2]:
            raise RuntimeError

        pymat.eval(self.handle,
                   '[acquisition, focus] = %s(image,image_id)' % f[:-2])

        focus = pymat.get(self.handle, 'focus')
        acquisition = pymat.get(self.handle, 'acquisition')

        self.setTargets(acquisition, 'acquisition')
        self.setTargets(focus, 'focus')
        import time
        time.sleep(1)

        if self.settings['user check']:
            self.panel.foundTargets()
def get3d(handle, name):
    mlabraw.eval(handle, """
    flat_array = %s(:);
    shape = size(%s);
    """%(name, name))
    flat_array = mlabraw.get(handle, "flat_array")
    shape = map(int, mlabraw.get(handle, "shape").flat)
    return np.ndarray(buffer = flat_array, shape = shape, order="F")
Exemple #3
0
 def _get(self, name, remove=False):
     varname = name
     vartype = self._var_type(varname)
     if vartype in self._mlabraw_can_convert:
         var = mlabraw.get(self._session, varname)
         if type(var) is Numeric.ArrayType:
             if self._flatten_row_vecs and Numeric.shape(var)[0] == 1:
                 var.shape = var.shape[1:2]
             elif self._flatten_col_vecs and Numeric.shape(var)[1] == 1:
                 var.shape = var.shape[0:1]
             if self._array_cast:
                 var = self._array_cast(var)
     else:
         var = None
         if self._optionally_convert.get(vartype):
             # manual conversions may fail (e.g. for multidimensional
             # cell arrays), in that case just fall back on proxying.
             try:
                 var = self._manually_convert(varname, vartype)
             except MlabConversionError: pass
         if var is None:
             # we can't convert this to a python object, so we just
             # create a proxy, and don't delete the real matlab
             # reference until the proxy is garbage collected
             var = self._make_proxy(varname)
     if remove:
         mlabraw.eval(self._session, "clear('%s');" % varname)
     return var
Exemple #4
0
    def _get(self, name, remove=False):
        r"""Directly access a variable in matlab space.

        This should normally not be used by user code."""
        # FIXME should this really be needed in normal operation?
        if name in self._proxies: return self._proxies[name]
        varname = name
        vartype = self._var_type(varname)
        if vartype in self._mlabraw_can_convert:
            var = mlabraw.get(self._session, varname)
            if isinstance(var, ndarray):
                if self._flatten_row_vecs and numpy.shape(var)[0] == 1:
                    var.shape = var.shape[1:2]
                elif self._flatten_col_vecs and numpy.shape(var)[1] == 1:
                    var.shape = var.shape[0:1]
                if self._array_cast:
                    var = self._array_cast(var)
        else:
            var = None
            if self._dont_proxy.get(vartype):
                # manual conversions may fail (e.g. for multidimensional
                # cell arrays), in that case just fall back on proxying.
                try:
                    var = self._manually_convert(varname, vartype)
                except MlabConversionError:
                    pass
            if var is None:
                # we can't convert this to a python object, so we just
                # create a proxy, and don't delete the real matlab
                # reference until the proxy is garbage collected
                var = self._make_proxy(varname)
        if remove:
            mlabraw.eval(self._session, "clear('%s');" % varname)
        return var
Exemple #5
0
    def _get(self, name, remove=False):
        r"""Directly access a variable in matlab space. 

        This should normally not be used by user code."""
        # FIXME should this really be needed in normal operation?
        if name in self._proxies: return self._proxies[name]
        varname = name
        vartype = self._var_type(varname)
        if vartype in self._mlabraw_can_convert:
            var = mlabraw.get(self._session, varname)
            if isinstance(var, ndarray):
                if var.shape:
                  if self._flatten_row_vecs and numpy.shape(var)[0] == 1:
                      var.shape = var.shape[1:2]
                  elif len(var.shape) > 1 and self._flatten_col_vecs and numpy.shape(var)[1] == 1:
                      var.shape = var.shape[0:1]
                if self._array_cast:
                    var = self._array_cast(var)
        else:
            var = None
            if self._dont_proxy.get(vartype):
                # manual conversions may fail (e.g. for multidimensional
                # cell arrays), in that case just fall back on proxying.
                try:
                    var = self._manually_convert(varname, vartype)
                except MlabConversionError: pass
            if var is None:
                # we can't convert this to a python object, so we just
                # create a proxy, and don't delete the real matlab
                # reference until the proxy is garbage collected
                var = self._make_proxy(varname)
        if remove:
            mlabraw.eval(self._session, "clear('%s');" % varname)
        return var
Exemple #6
0
 def _var_type(self, varname):
     mlabraw.eval(self._session,
                  "TMP_CLS__ = class(%(x)s); if issparse(%(x)s),"
                  "TMP_CLS__ = [TMP_CLS__,'-sparse']; end;" % dict(x=varname))
     res_type = mlabraw.get(self._session, "TMP_CLS__")
     mlabraw.eval(self._session, "clear TMP_CLS__;") # unlikely to need try/finally to ensure clear
     return res_type
 def transform_points(self, points):
     
     mlabraw.put(self.handle, "points", points)
     mlabraw.eval(self.handle,"""
     points_result = tps_eval(points, params);        
     """)
     points_result = mlabraw.get(self.handle, "points_result")
     return points_result
Exemple #8
0
 def _var_type(self, varname):
     mlabraw.eval(
         self._session, "TMP_CLS__ = class(%(x)s); if issparse(%(x)s),"
         "TMP_CLS__ = [TMP_CLS__,'-sparse']; end;" % dict(x=varname))
     res_type = mlabraw.get(self._session, "TMP_CLS__")
     mlabraw.eval(
         self._session,
         "clear TMP_CLS__;")  # unlikely to need try/finally to ensure clear
     return res_type
def branch_points(bw):
    initialize()
    mlabraw.put(MATLAB, "bw",bw)
    mlabraw.eval(MATLAB, """
    bp = bwmorph(bw,'branchpoints')
    bp_d = double(bp);
    """)
    bp_d = mlabraw.get(MATLAB, "bp_d")
    bp =  bp_d.astype('uint8')
    return bp
def branch_points(bw):
    initialize()
    mlabraw.put(MATLAB, "bw", bw)
    mlabraw.eval(
        MATLAB, """
    bp = bwmorph(bw,'branchpoints')
    bp_d = double(bp);
    """)
    bp_d = mlabraw.get(MATLAB, "bp_d")
    bp = bp_d.astype('uint8')
    return bp
    def _var_type(self, varname):
        """Ask matlab what the type of varname is.

        :param varname: string variable
        :return: string type, e.g. ``double`` or ``char``.
        """

        mlabraw.eval(self._session,
                     "TMP_CLS__ = class(%(x)s); if issparse(%(x)s),"
                     "TMP_CLS__ = [TMP_CLS__,'-sparse']; end;" % dict(x=varname))
        res_type = mlabraw.get(self._session, "TMP_CLS__")
        mlabraw.eval(self._session, "clear TMP_CLS__;") # unlikely to need try/finally to ensure clear
        return res_type
Exemple #12
0
    def _var_type(self, varname):
        """Ask matlab what the type of varname is.

        :param varname: string variable
        :return: string type, e.g. ``double`` or ``char``.
        """

        mlabraw.eval(self._session,
                     "TMP_CLS__ = class(%(x)s); if issparse(%(x)s),"
                     "TMP_CLS__ = [TMP_CLS__,'-sparse']; end;" % dict(x=varname))
        res_type = mlabraw.get(self._session, "TMP_CLS__")
        mlabraw.eval(self._session, "clear TMP_CLS__;") # unlikely to need try/finally to ensure clear
        return res_type
    def transform_poses(self, points, rots):
        mlabraw.put(self.handle, "points", points)                
        put3d(self.handle, "rots", rots)
        
        mlabraw.eval(self.handle,"""
        [points_result, rots_result] = tps_eval_frames(points, rots, params);
        """)
        points_result = mlabraw.get(self.handle,"points_result")
        rots_result = get3d(self.handle, "rots_result")
        
        return points_result, rots_result


        
        def matlabFindTargets(self):
                pymat.put(self.handle, 'focus', [])
                pymat.put(self.handle, 'acquisition', [])

                d, f = os.path.split(self.settings['module path'])

                if d:
                        pymat.eval(self.handle, 'path(path, \'%s\')' % d)

                if not f[:-2]:
                        raise RuntimeError

                pymat.eval(self.handle, '[acquisition, focus] = %s(image,image_id)' % f[:-2])

                focus = pymat.get(self.handle, 'focus')
                acquisition = pymat.get(self.handle, 'acquisition')

                self.setTargets(acquisition, 'acquisition')
                self.setTargets(focus, 'focus')
                import time
                time.sleep(1)

                if self.settings['user check']:
                        self.panel.foundTargets()
Exemple #15
0
    def testRawMlabraw(self):
        """A few explicit tests for mlabraw"""
        import mlabraw
        #print "test mlabraw"
        self.assertRaises(TypeError, mlabraw.put, 33, 'a', 1)
        self.assertRaises(TypeError, mlabraw.get, object(), 'a')
        self.assertRaises(TypeError, mlabraw.eval, object(), '1')

        # -100 is picked kinda arbitrarily to account for internal "overhead";
        # I don't want to hardcode the exact value; users can assume 1000
        # chars is safe
        mlabraw.eval(mlab._session, '1' * (BUFSIZE - 100))
        assert numpy.inf == mlabraw.get(mlab._session, 'ans');
        # test for buffer overflow detection
        self.assertRaises(Exception, mlabraw.eval, mlab._session, '1' * BUFSIZE)
def remove_holes(labels,min_size):
    initialize()
    mlabraw.put(MATLAB, "L",labels)
    mlabraw.put(MATLAB, "min_size",min_size)
    mlabraw.eval(MATLAB, """
    max_label = max(L(:));
    good_pix = L==0;
    for label = 1:max_label
        good_pix = good_pix | bwareaopen(L==label,min_size,4);    
    end
    bad_pix = ~logical(good_pix);
    
    [~,I] = bwdist(good_pix,'Chessboard');
    NewL = L;
    NewL(bad_pix) = L(I(bad_pix));
    NewL_d = double(NewL);
    """)
    NewL_d = mlabraw.get(MATLAB, "NewL_d")
    return NewL_d.astype('uint8')
def remove_holes(labels, min_size):
    initialize()
    mlabraw.put(MATLAB, "L", labels)
    mlabraw.put(MATLAB, "min_size", min_size)
    mlabraw.eval(
        MATLAB, """
    max_label = max(L(:));
    good_pix = L==0;
    for label = 1:max_label
        good_pix = good_pix | bwareaopen(L==label,min_size,4);    
    end
    bad_pix = ~logical(good_pix);
    
    [~,I] = bwdist(good_pix,'Chessboard');
    NewL = L;
    NewL(bad_pix) = L(I(bad_pix));
    NewL_d = double(NewL);
    """)
    NewL_d = mlabraw.get(MATLAB, "NewL_d")
    return NewL_d.astype('uint8')
Exemple #18
0
    def testRawMlabraw(self):
        """A few explicit tests for mlabraw"""
        import mlabraw
        #print "test mlabraw"
        self.assertRaises(TypeError, mlabraw.put, 33, 'a', 1)
        self.assertRaises(TypeError, mlabraw.get, object(), 'a')
        self.assertRaises(TypeError, mlabraw.eval, object(), '1')

        # -100 is picked kinda arbitrarily to account for internal "overhead";
        # I don't want to hardcode the exact value; users can assume 1000
        # chars is safe
        mlabraw.eval(mlab._session, '1' * (BUFSIZE - 100))
        assert numpy.inf == mlabraw.get(mlab._session, 'ans')
        # test for buffer overflow detection
        self.assertRaises(Exception, mlabraw.eval, mlab._session,
                          '1' * BUFSIZE)
        self.assertEqual(mlabraw.eval(mlab._session, r"fprintf('1\n')"), '1\n')
        try:
            self.assertEqual(mlabraw.eval(mlab._session, r"1"), '')
        finally:
            mlabraw.eval(mlab._session, 'clear ans')
def runAce(matlab, imgdata, params, showprev=True):
	imgname = imgdata['filename']

	if showprev is True:
		bestctfvalue = ctfdb.getBestCtfByResolution(imgdata)
		if bestctfvalue:
			bestconf = ctfdb.calculateConfidenceScore(bestctfvalue)
			print ( "Prev best: '"+bestctfvalue['acerun']['name']+"', conf="+
				apDisplay.colorProb(bestconf)+", defocus="+str(round(-1.0*abs(bestctfvalue['defocus1']*1.0e6),2))+
				" microns" )

	if params['uncorrected']:
		tmpname='temporaryCorrectedImage.mrc'
		imgarray = apDBImage.correctImage(imgdata)
		imgpath = os.path.join(params['rundir'],tmpname)
		apImage.arrayToMrc(imgarray, imgpath)
		print "processing", imgpath
	else:
		imgpath = os.path.join(imgdata['session']['image path'], imgname+'.mrc')

	nominal = None
	if params['nominal'] is not None:
		nominal=params['nominal']
	elif params['newnominal'] is True:
		bestctfvalue = ctfdb.getBestCtfByResolution(imgdata)
		nominal = bestctfvalue['defocus1']
	if nominal is None:
		nominal = imgdata['scope']['defocus']

	if nominal is None or nominal > 0 or nominal < -15e-6:
			apDisplay.printWarning("Nominal should be of the form nominal=-1.2e-6"+\
				" for -1.2 microns NOT:"+str(nominal))

	#Neil's Hack
	#if 'autosample' in params and params['autosample']:
	#	x = abs(nominal*1.0e6)
	#	val = 1.585 + 0.057587 * x - 0.044106 * x**2 + 0.010877 * x**3
	#	resamplefr_override = round(val,3)
	#	print "resamplefr_override=",resamplefr_override
	#	pymat.eval(matlab, "resamplefr="+str(resamplefr_override)+";")

	pymat.eval(matlab,("dforig = %e;" % nominal))

	if params['stig'] == 0:
		plist = (imgpath, params['outtextfile'], params['display'], params['stig'],\
			params['medium'], -nominal, params['tempdir']+"/")
		acecmd = makeMatlabCmd("ctfparams = ace(",");",plist)
	else:
		plist = (imgname, imgpath, params['outtextfile'], params['opimagedir'], \
			params['matdir'], params['display'], params['stig'],\
			params['medium'], -nominal, params['tempdir']+"/", params['resamplefr'])
		acecmd = makeMatlabCmd("ctfparams = measureAstigmatism(",");",plist)

	#print acecmd
	pymat.eval(matlab,acecmd)

	matfile = os.path.join(params['matdir'], imgname+".mrc.mat")
	if params['stig']==0:
		savematcmd = "save('"+matfile+"','ctfparams','scopeparams', 'dforig');"
		pymat.eval(matlab,savematcmd)

	ctfvalue = pymat.get(matlab, 'ctfparams')
	ctfvalue=ctfvalue[0]

	printResults(params, nominal, ctfvalue)

	return ctfvalue
def get(name):
    return mlabraw.get(MATLAB, name)
Exemple #21
0
 def get(self, name):
     if DEBUG: print "getting '%s'"%name
     return mlabraw.get(self._engine, name)
def get(name):
    return mlabraw.get(MATLAB, name)
Exemple #23
0
    def _execute(self):

        batch_size = self.batch_size
        pooling_region_counts = self.pooling_region_counts
        dataset_family = self.dataset_family
        which_set = self.which_set
        size = self.size

        nan = 0


        dataset_descriptor = dataset_family[which_set][size]

        dataset = dataset_descriptor.dataset_maker()
        expected_num_examples = dataset_descriptor.num_examples

        full_X = dataset.get_design_matrix()
        num_examples = full_X.shape[0]
        assert num_examples == expected_num_examples

        if self.restrict is not None:
            assert self.restrict[1]  <= full_X.shape[0]

            print 'restricting to examples ',self.restrict[0],' through ',self.restrict[1],' exclusive'
            full_X = full_X[self.restrict[0]:self.restrict[1],:]

            assert self.restrict[1] > self.restrict[0]

        #update for after restriction
        num_examples = full_X.shape[0]

        assert num_examples > 0

        dataset.X = None
        dataset.design_loc = None
        dataset.compress = False

        patchifier = ExtractGridPatches( patch_shape = (size,size), patch_stride = (1,1) )

        pipeline = serial.load(dataset_descriptor.pipeline_path)

        assert isinstance(pipeline.items[0], ExtractPatches)
        pipeline.items[0] = patchifier


        print 'defining features'
        Z = T.matrix('Z')

        if self.one_sided:
            feat = abs(Z)
        else:
            pos = T.clip(Z,0.,1e30)
            neg = T.clip(-Z,0.,1e30)

            feat = T.concatenate((pos, neg), axis=1)

        print 'compiling theano function'
        f = function([Z],feat)

        nfeat = self.W.shape[1] * (2 - self.one_sided)
        if not (nfeat == 1600 or nfeat == 3200):
            print nfeat
            assert False

        if config.device.startswith('gpu') and nfeat >= 4000:
            f = halver(f, nfeat)

        topo_feat_var = T.TensorType(broadcastable = (False,False,False,False), dtype='float32')()
        region_features = function([topo_feat_var],
                topo_feat_var.mean(axis=(1,2)) )

        def average_pool( stride ):
            def point( p ):
                return p * ns / stride

            rval = np.zeros( (topo_feat.shape[0], stride, stride, topo_feat.shape[3] ) , dtype = 'float32')

            for i in xrange(stride):
                for j in xrange(stride):
                    rval[:,i,j,:] = region_features( topo_feat[:,point(i):point(i+1), point(j):point(j+1),:] )

            return rval

        outputs = [ np.zeros((num_examples,count,count,nfeat),dtype='float32') for count in pooling_region_counts ]

        assert len(outputs) > 0

        fd = DenseDesignMatrix(X = np.zeros((1,1),dtype='float32'), view_converter = DefaultViewConverter([1, 1, nfeat] ) )

        ns = 32 - size + 1
        depatchifier = ReassembleGridPatches( orig_shape  = (ns, ns), patch_shape=(1,1) )

        if len(range(0,num_examples-batch_size+1,batch_size)) <= 0:
            print num_examples
            print batch_size

        for i in xrange(0,num_examples-batch_size+1,batch_size):
            print i
            t1 = time.time()

            d = copy.copy(dataset)
            d.set_design_matrix(full_X[i:i+batch_size,:])

            t2 = time.time()

            #print '\tapplying preprocessor'
            d.apply_preprocessor(pipeline, can_fit = False)
            X2 = d.get_design_matrix()

            t3 = time.time()

            M.put(s,'batch',X2)

            M.eval(s, 'Z = sparse_codes(batch, dictionary, lambda)')
            Z = M.get(s, 'Z')

            feat = f(np.cast['float32'](Z))

            t4 = time.time()

            assert feat.dtype == 'float32'

            feat_dataset = copy.copy(fd)

            if np.any(np.isnan(feat)):
                nan += np.isnan(feat).sum()
                feat[np.isnan(feat)] = 0

            feat_dataset.set_design_matrix(feat)

            #print '\treassembling features'
            feat_dataset.apply_preprocessor(depatchifier)

            #print '\tmaking topological view'
            topo_feat = feat_dataset.get_topological_view()
            assert topo_feat.shape[0] == batch_size

            t5 = time.time()

            #average pooling
            for output, count in zip(outputs, pooling_region_counts):
                output[i:i+batch_size,...] = average_pool(count)

            t6 = time.time()

            print (t6-t1, t2-t1, t3-t2, t4-t3, t5-t4, t6-t5)

        for output, save_path in zip(outputs, self.save_paths):
            if self.chunk_size is not None:
                assert save_path.endswith('.npy')
                save_path_pieces = save_path.split('.npy')
                assert len(save_path_pieces) == 2
                assert save_path_pieces[1] == ''
                save_path = save_path_pieces[0] + '_' + chr(ord('A')+self.chunk_id)+'.npy'
            np.save(save_path,output)


        if nan > 0:
            warnings.warn(str(nan)+' features were nan')
def runAce(matlab, imgdata, params, showprev=True):
        imgname = imgdata['filename']

        if showprev is True:
                bestctfvalue, bestconf = ctfdb.getBestCtfValueForImage(imgdata)
                if bestctfvalue:
                        print ( "Prev best: '"+bestctfvalue['acerun']['name']+"', conf="+
                                apDisplay.colorProb(bestconf)+", defocus="+str(round(-1.0*abs(bestctfvalue['defocus1']*1.0e6),2))+
                                " microns" )

        if params['uncorrected']:
                tmpname='temporaryCorrectedImage.mrc'
                imgarray = apDBImage.correctImage(imgdata)
                imgpath = os.path.join(params['rundir'],tmpname)
                apImage.arrayToMrc(imgarray, imgpath)
                print "processing", imgpath
        else:
                imgpath = os.path.join(imgdata['session']['image path'], imgname+'.mrc')

        nominal = None
        if params['nominal'] is not None:
                nominal=params['nominal']
        elif params['newnominal'] is True:
                nominal = ctfdb.getBestDefocusForImage(imgdata, msg=True)
        if nominal is None:
                nominal = imgdata['scope']['defocus']

        if nominal is None or nominal > 0 or nominal < -15e-6:
                        apDisplay.printWarning("Nominal should be of the form nominal=-1.2e-6"+\
                                " for -1.2 microns NOT:"+str(nominal))

        #Neil's Hack
        #if 'autosample' in params and params['autosample']:
        #       x = abs(nominal*1.0e6)
        #       val = 1.585 + 0.057587 * x - 0.044106 * x**2 + 0.010877 * x**3
        #       resamplefr_override = round(val,3)
        #       print "resamplefr_override=",resamplefr_override
        #       pymat.eval(matlab, "resamplefr="+str(resamplefr_override)+";")

        pymat.eval(matlab,("dforig = %e;" % nominal))

        if params['stig'] == 0:
                plist = (imgpath, params['outtextfile'], params['display'], params['stig'],\
                        params['medium'], -nominal, params['tempdir']+"/")
                acecmd = makeMatlabCmd("ctfparams = ace(",");",plist)
        else:
                plist = (imgname, imgpath, params['outtextfile'], params['opimagedir'], \
                        params['matdir'], params['display'], params['stig'],\
                        params['medium'], -nominal, params['tempdir']+"/", params['resamplefr'])
                acecmd = makeMatlabCmd("ctfparams = measureAstigmatism(",");",plist)

        #print acecmd
        pymat.eval(matlab,acecmd)

        matfile = os.path.join(params['matdir'], imgname+".mrc.mat")
        if params['stig']==0:
                savematcmd = "save('"+matfile+"','ctfparams','scopeparams', 'dforig');"
                pymat.eval(matlab,savematcmd)

        ctfvalue = pymat.get(matlab, 'ctfparams')
        ctfvalue=ctfvalue[0]

        ctfdb.printResults(params, nominal, ctfvalue)

        return ctfvalue
Exemple #25
0
 def _var_type(self, varname):
     mlabraw.eval(self._session, "TMP_CLS__ = class(%s);" % varname) #FIXME for funcs we would need ''s
     res_type = mlabraw.get(self._session, "TMP_CLS__")
     mlabraw.eval(self._session, "clear TMP_CLS__;")
     return res_type