Пример #1
1
def load_envi_file(filename):
	IDL.run('envi')
	IDL.ENVI_OPEN_FILE(filename)
Пример #2
1
def load_array(arr):
	IDL.run('envi')
	IDL.ENVI_ENTER_DATA(arr)
Пример #3
1
            rfra = (rmax) + (cc[rmax+1,cmax] -cc[rmax-1,cmax])/denom
            denom = 2.*(2.*cc.max() - cc[rmax,cmax+1] - cc[rmax, cmax-1])
            cfra = (cmax) + (cc[rmax,cmax+1] -cc[rmax,cmax-1])/denom
            rmax = rfra
            cmax = cfra
        return np.array([rmax - d0n.shape[0]/2. , cmax - d0n.shape[1]/2.])
        
######################################################
  
if __name__ == "__main__":
    from idlpy import IDL
    import numpy as np 
    import time
    a  = np.random.rand(1024)
    b  = np.random.rand(1024)
    print "IDL 1d SHC return: ",IDL.shc(a,b) 
    print "Python 1d SHC numpy return:", shc_numpy(a,b)
    print "Python 1d SHC opencv return:", shc_opencv(a,b)
    aa = np.random.rand(1248,4238)
    aa[10:20,20:45] = 100.
    bb = np.random.rand(1248,4238)
    bb[15:25,21:46] = 100.
    print "IDL 2D SHC return:",IDL.shc(aa,bb)
    print "Python 2D SHC numpy return:",shc_numpy(aa,bb)
    print "Python 2D SHC opencv return:",shc_opencv(aa,bb)
    start = time.time()
    shc_numpy(aa,bb)
    end = time.time()
    print("numpy time:",end - start)
    start = time.time()
    shc_opencv(aa,bb)
Пример #4
0
def load_external_file(filename):
	IDL.run('envi')

	name, ext = os.path.splitext(os.path.basename(filename))

	if ext in ['.tif', '.tiff']:
		IDL.ENVI_OPEN_DATA_FILE(filename, TIFF=1)
	elif ext in ['.txt', '.met']:
		IDL.ENVI_OPEN_DATA_FILE(filename, LANDSAT_METADATA=1)
Пример #5
0
def dspk_idl(data, std_dev=4.5, Niter=10):

    # IDL.run('$ pwd', stdout=1)
    cwd = os.path.dirname(os.path.realpath(__file__))
    dir = cwd + '/../../idl/dspk"'
    cmd = '!path = !path + ":' + dir
    IDL.run(cmd)
    # IDL.run('print, !path', stdout=1)

    return IDL.despik(data, sigmas=std_dev, Niter=Niter)
Пример #6
0
    def idl_do_execute(self, code, call_result, graphics):
        call_line = ''

        for each in code.splitlines():
            each = each.rstrip()
            if each.lower().startswith('.run'):
                continue

            if len(each) > 0 and each[-1] == '$':
                call_line += each[0:-1]
                continue
            else:
                call_line += each

            result = IDL.run(call_line)
            call_line = ''

            idlmagic = getattr(IDL, '!MAGIC')
            if idlmagic['WINDOW'] != -1 and idlmagic['WINDOW'] not in graphics:
                graphics[idlmagic['WINDOW']] = idlmagic
                call_result.append(self._graphicid)
            if result is not None:
                call_result.append(result)

            if '.res' in each.lower() or '.f' in each.lower():
                self.idl_initGConfig()
Пример #7
0
    def top2wgs(self, top_latitude, top_elevation):
        IDL.top_latitude = top_latitude
        IDL.top_elevation = top_elevation

        wgs_latitude = None
        IDL.wgs_latitude = wgs_latitude
        wgs_elevation = None
        IDL.wgs_elevation = wgs_elevation

        # IDL.run('print, top_latitude, top_elevation', stdout=True)
        # IDL.run('print, wgs_latitude, wgs_elevation', stdout=True)

        IDL.run(
            'top2wgs, top_latitude, top_elevation, wgs_latitude, wgs_elevation',
            stdout=True)
        wgs_latitude = IDL.wgs_latitude  # pass by value
        wgs_elevation = IDL.wgs_elevation  # pass by value

        return wgs_latitude, wgs_elevation
Пример #8
0
def init_ENVI():
    """
	Initialises ENVI. Should never need to be called manually, as will be called
	automatically where necessary.
	"""
    global e

    if e is None:
        print("Initialising ENVI")
        e = IDL.ENVI()
Пример #9
0
def generate_test_data():
    """
    Run IDL ANDROMEDA and create ``andromeda_idl.npz``.
    """
    global DATACUBE

    from idlpy import IDL as idl

    idl.cube = DATACUBE.cube
    idl.angles = DATACUBE.angles
    idl.psf = DATACUBE.psf

    idl.run("andromeda_contrast_1 = ANDROMEDA("
            "IMAGES_1_INPUT=cube,"
            "ANGLES_INPUT=angles,"
            "PSF_PLANET_INPUT=psf,"
            "OVERSAMPLING_1_INPUT=1,"
            "FILTERING_FRACTION_INPUT=1,"  # turn off high pass
            "MINIMUM_SEPARATION_INPUT=0.3,"
            "OPT_METHOD_ANG_INPUT=1,"  # no optimization
            "NSMOOTH_SNR_INPUT=0,"  # turn off smoothing
            "/HOMOGENEOUS_VARIANCE_INPUT,"
            ""  # output:
            "SNR_OUTPUT=andromeda_snr_1,"
            "SNR_NORM_OUTPUT=andromeda_snr_norm_1,"
            "LIKELIHOOD_OUTPUT=andromeda_likelihood_1,"
            "STDDEVCONTRAST_OUTPUT=andromeda_stddevcontrast_1,"
            "STDDEVCONTRAST_NORM_OUTPUT=andromeda_stddevcontrast_norm_1,"
            "EXT_RADIUS_OUTPUT=andromeda_ext_radius_1)")

    OUT = {}
    OUT["andromeda_contrast_1"] = idl.andromeda_contrast_1
    OUT["andromeda_snr_1"] = idl.andromeda_snr_1
    OUT["andromeda_snr_norm_1"] = idl.andromeda_snr_norm_1
    OUT["andromeda_likelihood_1"] = idl.andromeda_likelihood_1
    OUT["andromeda_stdcontrast_1"] = idl.andromeda_stddevcontrast_1
    OUT["andromeda_stdcontrast_norm_1"] = idl.andromeda_stddevcontrast_norm_1

    np.savez_compressed(os.path.join(CURRDIR, "andromeda_idl.npz"), **OUT)
Пример #10
0
    def idl_output_result(self, result, graphics):

        # Check if PNG
        if result == self._graphicid and len(graphics) > 0:
            # Returns a tuple with the window ID and !magic info.
            idlmagic = graphics.popitem(False)[1]
            img = IDL.EncodeGraphic(idlmagic['WINDOW'], idlmagic['TYPE'])
            if img != None:
                # See Python logging module
                #                self.log.warning("IDL graphic " + str(idlmagic['WINDOW']) + " md5=" +
                #                    hashlib.md5(img.encode()).hexdigest())
                width = str(idlmagic['XSIZE'])
                height = str(idlmagic['YSIZE'])
                response = {
                    'data': {
                        'image/png': img
                    },
                    'metadata': {
                        'image/png': {
                            'width': width,
                            'height': height
                        }
                    }
                }
            else:
                err = 'Error: Unable to encode graphics window ' + str(
                    idlmagic['WINDOW']) + '\n'
                response = {'data': {'text/plain': err}, 'metadata': {}}
        else:
            if result.startswith("<html>"):
                response = {
                    'data': {
                        'text/html': result + '\n'
                    },
                    'metadata': {}
                }
            else:
                response = {
                    'data': {
                        'text/plain': result + '\n'
                    },
                    'metadata': {}
                }

        self.send_response(self.iopub_socket, 'display_data', response)
Пример #11
0
 def idl_initGConfig(self):
     IDL.run("compile_opt idl2", silent=True)
     IDL.run("!QUIET=1 & !MAGIC.embed=1 & !MAGIC.window=-1", silent=True)
Пример #12
0
 def __init__(self):
     super(self.__class__, self).__init__()
     curPath = os.path.split(thisfile__abspath)[0]
     savFilePath = os.path.join(curPath, "ellipsoid.sav")
     IDL.run('restore, FILENAME = \'{0}\''.format(savFilePath), stdout=True)
Пример #13
0
    def __init__(self, varfile='pvar.dat', npar_max=-1,
                 datadir=False, sim=False, proc=-1, swap_endian=False, quiet=False, DEBUG=False):
        """
        Read PVAR files from Pencil Code using IDL.
        Uses IDL<->Python Bridge, this must be activated manually!

        Args:
            - datadir      specify datadir, default False
            - sim           specify simulation from which you want to read
            - varfile       put 'PVARXYZ' or just number here, 'VAR' will be replaced by 'PVAR' autom.
            - npar_max      maximal number of particles to be read in

            - proc          read from single proc, set number here
            - swap_endian   change if needed to True, default False
            - quiet         verbosity, default False

        """

        import numpy as np
        import os
        import pencilnew as pcn
        from pencilnew.math import is_number
        from sys import byteorder

        try:
            cwd = os.getcwd()
            from idlpy import IDL
            os.chdir(cwd)

        except:
            print('! ERROR: no idl<->python bridge found. Try whats written in pstalk-comment to fix that issue.')
            print('! ')
            print('! Use something like: (enshure you have IDL 8.5.1 or larger)')
            print('! export PYTHONPATH=$PYTHONPATH:$IDL_HOME/lib/bridges:$IDL_HOME/bin/bin.linux.x86_64')
            print('! export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib64:$IDL_HOME/bin/bin.linux.x86_64')
            print('! in your .bashrc')
            print('! ')
            return False

        ####### interprate parameters
        if datadir == False:
            if sim == False:
                sim = pcn.get_sim()
        datadir = sim.datadir

        if quiet == False:
            quiet = '0'
        else:
            quiet = '1'

        if swap_endian == False:
            if byteorder == 'little': swap_endian = '0'
            elif byteorder == 'big': swap_endian = '1'
        else: print('? WARNING: Couldnt determine endianness!')

        ####### preparing IDL call
        # cleanup of varfile string
        if is_number(varfile): varfile = 'PVAR'+str(varfile)
        varfile = str(varfile)
        if varfile=='var.dat': varfile='pvar.dat'
        if varfile[:3]=='VAR': varfile='P'+varfile

        #
        idl_call = ', '.join(['pc_read_pvar',
                              'obj=pvar',
                              'varfile="'+varfile+'"',
                              'datadir="'+datadir+'"',
                              'quiet='+quiet,
                              'swap_endian='+swap_endian,
                              'proc='+str(proc)
                              ])

        # reduce number of particles to be read in
        if npar_max > 0: idl_call= idl_call+', npar_max='+str(npar_max)

        ####### show idl_call string if DEBUG
        if DEBUG == True: print('~ DEBUG: idl_call: '+idl_call)

        ###### read in var file in IDL
        print('~ reading '+varfile+' in IDL..')
        IDL.run(idl_call)

        ####### parse to python
        print('~ parsing PVAR from IDL to python..')
        pvar = IDL.pvar

        for key in pvar.keys():
            setattr(self, key, pvar[key])
Пример #14
0
    def __init__(self,
                 datadir=False,
                 sim=False,
                 swap_endian=False,
                 quiet=False):
        """
        Read PSTALK files from Pencil Code using IDL.
        Uses IDL<->Python Bridge, this must be activated manually!

        Args:
            - datadir      specify datadir, default False
            - sim           specify simulation from which you want to read
            - swap_endian   change if needed to True, default False
            - quiet         verbosity, default False


        """

        import numpy as np
        import os
        import pencilnew as pcn
        try:
            cwd = os.getcwd()
            from idlpy import IDL
            os.chdir(cwd)

        except:
            print(
                '! ERROR: no idl<->python bridge found. Try whats written in pstalk-comment to fix that issue.'
            )
            print('! ')
            print(
                '! Use something like: (enshure you have IDL 8.5.1 or larger)')
            print(
                '! export PYTHONPATH=$PYTHONPATH:$IDL_HOME/lib/bridges:$IDL_HOME/bin/bin.linux.x86_64'
            )
            print(
                '! export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib64:$IDL_HOME/bin/bin.linux.x86_64'
            )
            print('! in your .bashrc')
            print('! ')

        print('~ reading pstalk in IDL..')

        if datadir == False:
            if sim == False:
                sim = pcn.get_sim()
            datadir = sim.datadir

        if quiet == False:
            quiet = '0'
        else:
            quiet = '1'

        if swap_endian == False:
            swap_endian = '0'
        else:
            swap_endian = '1'

        idl_call = ', '.join([
            'pc_read_pstalk', 'obj=pstalk', 'datadir="' + datadir + '"',
            'quiet=' + quiet, 'swap_endian=' + swap_endian
        ])

        IDL.run(idl_call)

        print('~ parsing pstalk from IDL to python..')
        ps = IDL.pstalk

        for key in ps.keys():
            setattr(self, key, ps[key].T)
Пример #15
0
    def __init__(self, datadir=False, sim=False,
                 tmin=0, tmax=-1, noutmax='-1',
                 swap_endian=False, quiet=False, use_existing_pstalk_sav=False):
        """
        Read PSTALK files from Pencil Code using IDL.
        Uses IDL<->Python Bridge, this must be activated manually!

        Args:
            - datadir      specify datadir, default False
            - sim           specify simulation from which you want to read
            - swap_endian   change if needed to True, default False
            - quiet         verbosity, default False
            - use_existing_pstalk_sav
                            use existing <sim.datadir>/data/pc/tmp/pstalk.sav for speed up


        """

        import numpy as np
        import os
        from os.path import join
        from .. import get_sim

        if datadir == False:
            if sim == False:
                sim = get_sim()
            datadir = sim.datadir

        if quiet == False:
            quiet = '0'
        else:
            quiet = '1'

        if swap_endian == False:
            swap_endian = '0'
        else:
            swap_endian = '1'

        if use_existing_pstalk_sav == True:
            from scipy.io.idl import readsav

            print('~ reading existing pstalk..')

            ps = readsav(join(sim.pc_datadir,'tmp','pstalk.sav'))('pstalk')

            for key in set(ps.dtype.fields.keys()):
                if hasattr(self, key.lower()): continue
                setattr(self, key.lower(), ps[key][0].T)

        else:
            try:
                cwd = os.getcwd()
                from idlpy import IDL
                os.chdir(cwd)

                print('~ reading pstalk in IDL..')

                idl_call = ', '.join(['pc_read_pstalk', 'obj=pstalk', 'datadir="'+datadir+'"', 'it0='+str(tmin), 'it1='+str(tmax), 'quiet='+quiet, 'swap_endian='+swap_endian, 'noutmax='+str(noutmax)])

                IDL.run(idl_call)

                print('~ parsing pstalk from IDL to python..')
                ps = IDL.pstalk

                for key in set(ps.keys()):
                    if hasattr(self, key.lower()): continue
                    setattr(self, key.lower(), ps[key].T)

            except:
                print('! ERROR: no idl<->python bridge found. Try whats written in pstalk-comment to fix that issue.')
                print('! ')
                print('! Use something like: (ensure you have IDL 8.5.1 or larger)')
                print('! export PYTHONPATH=$PYTHONPATH:$IDL_HOME/lib/bridges:$IDL_HOME/bin/bin.linux.x86_64')
                print('! export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib64:$IDL_HOME/bin/bin.linux.x86_64')
                print('! in your .bashrc')
                print('! ')
                print('! If you have it already installed, try: from idlpy import IDL and check for errors')
                print('! ')
                print('~ BACKUP SOLUTION: reading pstalk via pidly, starting IDL..')

                from ..backpack import pidly
                IDL = pidly.IDL(long_delay=0.05)	# start IDL engine
                from scipy.io.idl import readsav
                from ..io import mkdir

                ## read tstalk file
                print('## reading particle stalker file..')
                IDL('pc_read_pstalk, object=pstalk, datadir="'+sim.datadir+'"'+', quiet='+quiet+', it0='+str(tmin)+', it1='+str(tmax)+', swap_endian='+swap_endian)

                print('## transfering pstalk file from IDL to python..')
                mkdir(join(sim.pc_datadir,'tmp'))
                IDL('save, pstalk, filename="'+join(sim.pc_datadir,'tmp','pstalk_'+str(tmin)+'_'+str(tmax)+'.sav')+'"')
                ps = readsav(join(sim.pc_datadir,'tmp','pstalk.sav'))('pstalk')

                #from pc.io import debug_breakpoint; debug_breakpoint()

                for key in set(ps.dtype.fields.keys()):
                    if hasattr(self, key.lower()): continue
                    setattr(self, key.lower(), ps[key][0].T)
Пример #16
0
    def __init__(self, varfile='pvar.dat', npar_max=-1,
                 datadir=False, sim=False, proc=-1, swap_endian=False, quiet=False, DEBUG=False):
        """
        Read PVAR files from Pencil Code using IDL.
        Uses IDL<->Python Bridge, this must be activated manually!

        Args:
            - datadir      specify datadir, default False
            - sim           specify simulation from which you want to read
            - varfile       put 'PVARXYZ' or just number here, 'VAR' will be replaced by 'PVAR' autom.
            - npar_max      maximal number of particles to be read in

            - proc          read from single proc, set number here
            - swap_endian   change if needed to True, default False
            - quiet         verbosity, default False

        """

        import numpy as np
        import os
        import pencilnew as pcn
        from pencilnew.math import is_number
        from sys import byteorder

        try:
            cwd = os.getcwd()
            from idlpy import IDL
            os.chdir(cwd)

        except:
            print('! ERROR: no idl<->python bridge found. Try whats written in pstalk-comment to fix that issue.')
            print('! ')
            print('! Use something like: (enshure you have IDL 8.5.1 or larger)')
            print('! export PYTHONPATH=$PYTHONPATH:$IDL_HOME/lib/bridges:$IDL_HOME/bin/bin.linux.x86_64')
            print('! export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib64:$IDL_HOME/bin/bin.linux.x86_64')
            print('! in your .bashrc')
            print('! ')
            return None

        ####### interprate parameters
        if datadir == False:
            if sim == False:
                sim = pcn.get_sim()
        datadir = sim.datadir

        if quiet == False:
            quiet = '0'
        else:
            quiet = '1'

        if swap_endian == False:
            if byteorder == 'little': swap_endian = '0'
            elif byteorder == 'big': swap_endian = '1'
        else: print('? WARNING: Couldnt determine endianness!')

        ####### preparing IDL call
        # cleanup of varfile string
        if is_number(varfile): varfile = 'PVAR'+str(varfile)
        varfile = str(varfile)
        if varfile=='var.dat': varfile='pvar.dat'
        if varfile[:3]=='VAR': varfile='P'+varfile

        #
        idl_call = ', '.join(['pc_read_pvar',
                              'obj=pvar',
                              'varfile="'+varfile+'"',
                              'datadir="'+datadir+'"',
                              'quiet='+quiet,
                              'swap_endian='+swap_endian,
                              'proc='+str(proc)
                              ])

        # reduce number of particles to be read in
        if npar_max > 0: idl_call= idl_call+', npar_max='+str(npar_max)

        ####### show idl_call string if DEBUG
        if DEBUG == True: print('~ DEBUG: idl_call: '+idl_call)

        ###### read in var file in IDL
        print('~ reading '+varfile+' in IDL..')
        IDL.run(idl_call)

        ####### parse to python
        print('~ parsing PVAR from IDL to python..')
        pvar = IDL.pvar

        for key in pvar.keys():
            setattr(self, key.lower(), pvar[key])
        setattr(self, 'xp', pvar['XX'][0])
        setattr(self, 'yp', pvar['XX'][1])
        setattr(self, 'zp', pvar['XX'][2])
        setattr(self, 'vpx', pvar['VV'][0])
        setattr(self, 'vpy', pvar['VV'][1])
        setattr(self, 'vpz', pvar['VV'][2])
Пример #17
0
    def __init__(
        self,
        varfile="pvar.dat",
        npar_max=-1,
        datadir=False,
        sim=False,
        proc=-1,
        swap_endian=False,
        quiet=False,
        DEBUG=False,
    ):
        """
        Read PVAR files from Pencil Code using IDL.
        Uses IDL<->Python Bridge, this must be activated manually!

        Args:
            - datadir      specify datadir, default False
            - sim           specify simulation from which you want to read
            - varfile       put 'PVARXYZ' or just number here, 'VAR' will be replaced by 'PVAR' autom.
            - npar_max      maximal number of particles to be read in

            - proc          read from single proc, set number here
            - swap_endian   change if needed to True, default False
            - quiet         verbosity, default False

        """

        import numpy as np
        import os
        from pencil import get_sim
        from pencil.math import is_number
        from sys import byteorder

        ####### interpret parameters
        if datadir == False:
            if sim == False:
                sim = get_sim()
        datadir = sim.datadir

        l_h5 = False
        if os.path.exists(os.path.join(datadir, "grid.h5")):
            l_h5 = True
            import h5py
        if not l_h5:
            try:
                cwd = os.getcwd()
                from idlpy import IDL

                os.chdir(cwd)

            except:
                print(
                    "! ERROR: no idl<->python bridge found. Try whats written in pstalk-comment to fix that issue."
                )
                print("! ")
                print(
                    "! Use something like: (ensure you have IDL 8.5.1 or larger)"
                )
                print(
                    "! export PYTHONPATH=$PYTHONPATH:$IDL_HOME/lib/bridges:$IDL_HOME/bin/bin.linux.x86_64"
                )
                print(
                    "! export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib64:$IDL_HOME/bin/bin.linux.x86_64"
                )
                print("! in your .bashrc")
                print("! ")
                return None

        if not l_h5:
            if quiet == False:
                quiet = "0"
            else:
                quiet = "1"

            if swap_endian == False:
                if byteorder == "little":
                    swap_endian = "0"
                elif byteorder == "big":
                    swap_endian = "1"
            else:
                print("? WARNING: Couldnt determine endianness!")

        ####### preparing IDL call
        # cleanup of varfile string
        if is_number(varfile):
            varfile = "PVAR" + str(varfile)
        varfile = str(varfile)
        if varfile == "var.dat":
            varfile = "pvar.dat"
        if varfile[:3] == "VAR":
            varfile = "P" + varfile
        if l_h5:
            varfile = str.strip(varfile, ".dat") + ".h5"
            with h5py.File(os.path.join(datadir, "allprocs", varfile),
                           "r") as hf:
                for key in hf["part"].keys():
                    setattr(self, key.lower(), hf["part"][key][()])
        #
        else:
            idl_call = ", ".join([
                "pc_read_pvar",
                "obj=pvar",
                'varfile="' + varfile + '"',
                'datadir="' + datadir + '"',
                "quiet=" + quiet,
                "swap_endian=" + swap_endian,
                "proc=" + str(proc),
            ])

            # reduce number of particles to be read in
            if npar_max > 0:
                idl_call = idl_call + ", npar_max=" + str(npar_max)

            ####### show idl_call string if DEBUG
            if DEBUG == True:
                print("~ DEBUG: idl_call: " + idl_call)

            ###### read in var file in IDL
            print("~ reading " + varfile + " in IDL..")
            IDL.run(idl_call)

            ####### parse to python
            print("~ parsing PVAR from IDL to python..")
            pvar = IDL.pvar

            for key in pvar.keys():
                setattr(self, key.lower(), pvar[key])
            setattr(self, "xp", pvar["XX"][0])
            setattr(self, "yp", pvar["XX"][1])
            setattr(self, "zp", pvar["XX"][2])
            setattr(self, "vpx", pvar["VV"][0])
            setattr(self, "vpy", pvar["VV"][1])
            setattr(self, "vpz", pvar["VV"][2])
Пример #18
0
 def idl_resetGConfig(self):
     IDL.run("!MAGIC.window=-1", silent=True)
Пример #19
0
def startup():

    print("Loading Python-IDL bridge...")
    import os
    cur_dir = os.getcwd()

    # check that required environmentals are defined

    try:
        idl_dir = os.environ['IDL_DIR']
    except:
        print('$IDL_DIR is undefined.')
        return

    try:
        ssw = os.environ['SSW']
    except:
        print('$SSW is undefined. Defaulting to vanilla IDL.')
        ssw = None
        pass

# save personal IDL startup (to run later)

    try:
        pers_start = os.environ['IDL_STARTUP']
        os.environ['IDL_STARTUP'] = ''
    except:
        pers_start = ''
        pass

# switch to IDL bridge directory and import IDL-Python bridge object

    bridge_dir = os.path.join(idl_dir, 'lib', 'bridges')
    cur_dir = os.getcwd()
    os.chdir(bridge_dir)
    from idlpy import IDL

    # load preferred instruments

    if ssw:
        try:
            ssw_instr = os.environ['SSW_INSTR']
            IDL.ssw_instr = ssw_instr
            print('Loading: ' + ssw_instr)
            IDL.run("setenv,'SSW_INSTR='+ssw_instr")
        except:
            print('SSW_INSTR is undefined. Defaulting to GEN.')
            pass

        startup_dir = os.path.join(ssw, 'gen', 'idl', 'ssw_system')
        os.chdir(startup_dir)
        IDL.run("!quiet=1")
        IDL.run("ssw_load")
        IDL.run("a=is_pyidl(/set)")

# now load personal startup

    if os.path.isfile(pers_start):
        IDL.pers_start = pers_start
        os.environ['IDL_STARTUP'] = pers_start
        print('Executing personal IDL_STARTUP: ' + pers_start)
        IDL.run('@' + pers_start)

    IDL.run("!quiet=0")
    os.chdir(cur_dir)
    return IDL
def get_pyimage_arrays(sol, seq, train):
    # Get an array where each element is a list of files with the same pointing
    print getfile_command % (sol, seq)
    IDL.run(getfile_command % (sol, seq))
    img_list = IDL.img_list
    print img_list

    image_names = set([])
    for img_set in img_list:
        if len(img_set) < 6:
            print "# images = %d, skipping" % len(img_set)
            continue

        filter_count = 0
        for file in img_set:
            # We don't want to use the 0 (Bayer RGB true color) filter
            if 'A0' in file:
                print "Skipping A0"
                continue
            # Read the PDS file into an IDL array
            IDL.run(readpds_command % file)
            py_img = IDL.img

            print 'SHAPE: ', py_img.shape

            # Numpy references image dimensions as Y x X x N,
            # whereas IDL references as N x X x Y. We only keep
            # the relevant Bayer band with the most info for that filter.
            if 'ML' in file:
                ins = 'ML'
                if 'A1' in file:
                    img_0 = py_img[1, :, :]
                    filter_count += 1
                elif 'A2' in file:
                    img_1 = py_img[2, :, :]
                    filter_count += 1
                elif 'A3' in file:
                    img_2 = py_img[0, :, :]
                    filter_count += 1
                elif 'A4' in file:
                    img_3 = py_img[0, :, :]
                    filter_count += 1
                elif 'A5' in file:
                    img_4 = py_img[1, :, :]
                    filter_count += 1
                elif 'A6' in file:
                    img_5 = py_img[1, :, :]
                    filter_count += 1
            elif 'MR' in file:
                ins = 'MR'
                if 'A1' in file:
                    img_0 = py_img[1, :, :]
                    filter_count += 1
                elif 'A2' in file:
                    img_1 = py_img[2, :, :]
                    filter_count += 1
                elif 'A3' in file:
                    img_2 = py_img[0, :, :]
                    filter_count += 1
                elif 'A4' in file:
                    img_3 = py_img[1, :, :]
                    filter_count += 1
                elif 'A5' in file:
                    img_4 = py_img[1, :, :]
                    filter_count += 1
                elif 'A6' in file:
                    img_5 = py_img[1, :, :]
                    filter_count += 1

        # Check that it was actually a complete multispectral image
        if filter_count == 6:
            print "All filters accounted for"
            img_6f = np.ndarray([img_0.shape[0], img_0.shape[1], 6])
            img_6f[:, :, 0] = img_0
            img_6f[:, :, 1] = img_1
            img_6f[:, :, 2] = img_2
            img_6f[:, :, 3] = img_3
            img_6f[:, :, 4] = img_4
            img_6f[:, :, 5] = img_5

            version = file.split('R')[-1][0]
            new_name = '%s_%s_%s_%s.npy' % (seq, sol, ins, version)
            if new_name in image_names:
                new_name = '%s_%s_%s_%s_%d.npy' % (seq, sol, ins, version,
                                                   int(time.time() * 1000))
            else:
                image_names.add(new_name)
            if train:
                np.save(data_dir + '/train/' + new_name, img_6f)
            else:
                np.save(data_dir + '/expert/' + new_name, img_6f)