def runAceCorrect(imgdict,params):
        imgname = imgdict['filename']
        imgpath = os.path.join(imgdict['session']['image path'], imgname+'.mrc')

        voltage = (imgdict['scope']['high tension'])
        apix    = apDatabase.getPixelSize(imgdict)

        ctfvalues, conf = ctfdb.getBestCtfValueForImage(imgdict)

        ctdimname = imgname
        ctdimpath = os.path.join(params['rundir'],ctdimname)
        print "Corrected Image written to " + ctdimpath

        #pdb.set_trace()
        acecorrectcommand=("ctfcorrect1('%s', '%s', '%.32f', '%.32f', '%f', '%f', '%f');" % \
                (imgpath, ctdimpath, ctfvalues['defocus1'], ctfvalues['defocus2'], -ctfvalues['angle_astigmatism'], voltage, apix))
        print acecorrectcommand
        try:
                matlab = pymat.open("matlab -nosplash")
        except:
                apDisplay.environmentError()
                raise
        pymat.eval(matlab, acecorrectcommand)
        pymat.close(matlab)

        return

 def _get_part(self, to_get):
     if self._mlabwrap._var_type(to_get) in self._mlabwrap._mlabraw_can_convert:
         #!!! need assignment to TMP_VAL__ because `mlabraw.get` only works
         # with 'atomic' values like ``foo`` and not e.g. ``foo.bar``.
         mlabraw.eval(self._mlabwrap._session, "TMP_VAL__=%s" % to_get)
         return self._mlabwrap._get('TMP_VAL__', remove=True)
     return type(self)(self._mlabwrap, to_get, self)

 def __init__(self, display = False):
     import mlabraw
     if display:
         self.handle = mlabraw.open("matlab -logfile /tmp/matlablog")       
     else:
         self.handle = mlabraw.open("matlab -nodesktop -nodisplay -nojvm -logfile /tmp/matlablog")       
     mlabraw.eval(self.handle, "addpath('%s');"%os.path.join(os.path.dirname(lfd.__file__), "matlab"))

 def _get_values(self, varnames):
     if not varnames: raise ValueError("No varnames") #to prevent clear('')
     res = []
     for varname in varnames:
         res.append(self._get(varname))
     mlabraw.eval(self._session, "clear('%s');" % "','".join(varnames)) #FIXME wrap try/finally?
     return res

 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 _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

 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

 def eval_code(self, builder):
     self.builder = builder
 
     #should get a list of func names
     func_names = []
     for program in builder.project:
         print program.summary()
         #flatten tree and find Func.names
         nodes = program.flatten(False, False, False)
         for node in nodes:
             if node.cls == "Func":
                 func_names.append(node.name)
     
     #print func_names
     self.func_names = func_names
     self.called_func_names = []
     
     #check if main
     func = builder[0][1][0]
     
     if func.name == 'main':
         code_block = func[3]
     
         #evaluate, recursive function
         self._evaluate(code_block)
         mlabraw.eval(self.session, 'whos_f')
     else:
         print 'matlab have to run script file'

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")

 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

    def _set(self, name, value):
        r"""Directly set a variable `name` in matlab space to `value`.
        
        This should normally not be used in user code."""
        if isinstance(value, MlabObjectProxy):
            mlabraw.eval(self._session, "%s = %s;" % (name, value._name))
        else:
##             mlabraw.put(self._session, name, self._as_mlabable_type(value))
            mlabraw.put(self._session, name, value)

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 fit_transformation(self, points0, points1):
     assert len(points0) == len(points1)
     mlabraw.put(self.handle, "points0", points0)
     mlabraw.put(self.handle, "points1", points1)
     
     mlabraw.eval(self.handle, """
     opts = opts_fit;
     opts.reg = .01;
     params = tps_fit(points0, points1, opts);
     save('/tmp/after_fitting.mat');
     """)                

    def _make_proxy(self, varname, parent=None, constructor=MlabObjectProxy):
        """Creates a proxy for a variable.

        XXX create and cache nested proxies also here.
        """
        proxy_val_name = "PROXY_VAL%d__" % self._proxy_count
        self._proxy_count += 1
        mlabraw.eval(self._session, "%s = %s;" % (proxy_val_name, varname))
        res = constructor(self, proxy_val_name, parent)
        self._proxies[proxy_val_name] = res
        return res

    def _set(self, name, value):
        r"""Directly set a variable `name` in matlab space to `value`.
        
        This should normally not be used in user code."""
        if isinstance(value, MlabObjectProxy):
            mlabraw.eval(self._session, "%s = %s;" % (name, value._name))
        else:
##             mlabraw.put(self._session, name, self._as_mlabable_type(value))

            if isinstance(value, numpy.ndarray):
                value = value.copy() # XXX: mlabraw seems to badly handle strides.
            mlabraw.put(self._session, name, value)

    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 setScopeParams(matlab,params):
        tempdir = params['tempdir']+"/"
        if os.path.isdir(tempdir):
                plist = (params['kv'],params['cs'],params['apix'],tempdir)
                acecmd1 = makeMatlabCmd("setscopeparams(",");",plist)
                pymat.eval(matlab,acecmd1)

                plist = (params['kv'],params['cs'],params['apix'])
                acecmd2 = makeMatlabCmd("scopeparams = [","];",plist)
                pymat.eval(matlab,acecmd2)

        else:
                apDisplay.printError("Temp directory, '"+params['tempdir']+"' not present.")
        return

    def onRunParamGUI(self, evt):
        # added for GUI parametrization:

        self.handle = pymat.open()

        d, f = os.path.split(self.widgets["parametergui path"].GetValue())  # self.settings['parametergui path'])

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

        if not f[:-2]:
            raise RuntimeError

        pymat.eval(self.handle, "%s" % f[:-2])

    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 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)