Python numpy.fromregex函数代码示例

def readMaskRegion(regfile):
    box = numpy.fromregex(regfile,r"box\(([0-9]*\.?[0-9]+),(-[0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+)\",([0-9]*\.?[0-9]+)\",([0-9]*\.?[0-9]+)",
                          [('xc',numpy.float),('yc',numpy.float),('width',numpy.float),('height',numpy.float),('angle',numpy.float)])
    try:
        box[0]
    except IndexError:
        print 'Assuming a positive declination region.'
        box = numpy.fromregex(regfile,r"box\(([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+)\",([0-9]*\.?[0-9]+)\",([0-9]*\.?[0-9]+)",[('xc',numpy.float),('yc',numpy.float),('width',numpy.float),('height',numpy.float),('angle',numpy.float)])
        
    return box[0]

def loadobj(filename, load_normals=False):
    """ load a wavefront obj file
        loads vertices into a (x,y,z) struct array and vertex indices
        into a n x 3 index array 
        only loads obj files vertex positions and also
        only works with triangle meshes """
    vertices = np.fromregex(open(filename), _vertex_regex, np.float)
    if load_normals:
        normals = np.fromregex(open(filename), _normal_regex, np.float)
    triangles = np.fromregex(open(filename), _triangle_regex, np.int) - 1 # 1-based indexing in obj file format!
    if load_normals:
        return vertices, normals, triangles
    else:
        return vertices, triangles

def readheader(catalog):
    '''
    This function extracts the #ttype indexed header of a catalog.
    Input:
    catalog = [string], Name (perhaps including path) of the catalog
        that contains all of the data (e.g. x,y,e1,e2,...). Must include
        ttype header designations for the columns e.g.:
        #ttype0 = objid
        #ttype1 = x
    Output:
    dic = dictonary that contains the {ttype string,column #}.
    '''
    import numpy
    import sys
    header = numpy.fromregex(catalog,r"ttype([0-9]+)(?:\s)?=(?:\s)?(\w+)",
                                 [('column',numpy.int64),('name','S20')])
    # Determine if the catalog is 0 or 1 indexed and if 1 indexed then change to 0
    if header['column'][0] == 1:
        header['column']-=1
    elif header['column'][0] != 0:
        print 'readheader: the catalog is not ttype indexed, please index using format ttype(column#)=(column name), exiting'
        sys.exit()
    for i in range(len(header)):
        if i == 0:
            dic = {header[i][1]:header[i][0]}
        else:
            dic[header[i][1]]=header[i][0]
    return dic

def get_stocks():
    global gldict
    for name in names:
        filename = "%s.csv" % name
        if not os.path.exists(filename):
            yh_download(name)
        arr = fromregex(filename, yf_regex, yf_dtype)
        gldict[name] = arr

def read_orca_trj(fname):
    """return numpy 2D array
    """
    # http://stackoverflow.com/questions/14645789/
    # numpy-reading-file-with-filtering-lines-on-the-fly
    import numpy as np
    regexp = r'\s+\w+' + r'\s+([-.0-9]+)' * 3 + r'\s*\n'
    return np.fromregex(fname, regexp, dtype='f')

def readregions(regfile):
    '''
    regfile = (string) the ds9 region file, assumes that it was written using
              'ds9' Format and 'image' Coordinate System

    Currently this function only works on circles, ellipse, and box regions
    '''
    # find all the circle regions
    circ = numpy.fromregex(regfile,r"circle\(([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+)",[('xc',numpy.float),('yc',numpy.float),('rc',numpy.float)])

    # find all the elliptical regions
    ellip = numpy.fromregex(regfile,r"ellipse\(([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+)",[('xc',numpy.float),('yc',numpy.float),('a',numpy.float),('b',numpy.float),('angle',numpy.float)])

    # find all the box regions
    box = numpy.fromregex(regfile,r"box\(([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+),([0-9]*\.?[0-9]+)",[('xc',numpy.float),('yc',numpy.float),('width',numpy.float),('height',numpy.float),('angle',numpy.float)])

    return circ, ellip, box

    def test_record_3(self):
        c = StringIO.StringIO()
        c.write('1312 foo\n1534 bar\n4444 qux')
        c.seek(0)

        dt = [('num', np.float64)]
        x = np.fromregex(c, r"(\d+)\s+...", dt)
        a = np.array([(1312,), (1534,), (4444,)], dtype=dt)
        assert_array_equal(x, a)

    def test_record(self):
        c = StringIO.StringIO()
        c.write('1.312 foo\n1.534 bar\n4.444 qux')
        c.seek(0)

        dt = [('num', np.float64), ('val', 'S3')]
        x = np.fromregex(c, r"([0-9.]+)\s+(...)", dt)
        a = np.array([(1.312, 'foo'), (1.534, 'bar'), (4.444, 'qux')], dtype=dt)
        assert_array_equal(x, a)

    def test_record_2(self):
        c = StringIO()
        c.write(asbytes("1312 foo\n1534 bar\n4444 qux"))
        c.seek(0)

        dt = [("num", np.int32), ("val", "S3")]
        x = np.fromregex(c, r"(\d+)\s+(...)", dt)
        a = np.array([(1312, "foo"), (1534, "bar"), (4444, "qux")], dtype=dt)
        assert_array_equal(x, a)

    def test_record(self):
        c = StringIO()
        c.write(asbytes("1.312 foo\n1.534 bar\n4.444 qux"))
        c.seek(0)

        dt = [("num", np.float64), ("val", "S3")]
        x = np.fromregex(c, r"([0-9.]+)\s+(...)", dt)
        a = np.array([(1.312, "foo"), (1.534, "bar"), (4.444, "qux")], dtype=dt)
        assert_array_equal(x, a)

 def do_once(self):
     self.file.seek(0)
     output = numpy.fromregex(
         self.file, 
         self.line_re, 
         [('ip', 'S20'), ('day', 'S25'), ('month', 'S20'), ('year', 'S4'), ('time', 'S20'), ('method', 'S7'), ('path', 'S100'), ('size', numpy.int32)]
         )
     total_time_by_month = defaultdict(int)
     for row in output:
         total_time_by_month[(row[2], row[1])] += row[7]

    def test_record_2(self):
        return  # pass this test until #736 is resolved
        c = StringIO.StringIO()
        c.write("1312 foo\n1534 bar\n4444 qux")
        c.seek(0)

        dt = [("num", np.int32), ("val", "S3")]
        x = np.fromregex(c, r"(\d+)\s+(...)", dt)
        a = np.array([(1312, "foo"), (1534, "bar"), (4444, "qux")], dtype=dt)
        assert_array_equal(x, a)

    def test_record_2(self):
        c = StringIO.StringIO()
        c.write('1312 foo\n1534 bar\n4444 qux')
        c.seek(0)

        dt = [('num', np.int32), ('val', 'S3')]
        x = np.fromregex(c, r"(\d+)\s+(...)", dt)
        a = np.array([(1312, 'foo'), (1534, 'bar'), (4444, 'qux')],
                     dtype=dt)
        assert_array_equal(x, a)

def combine_history_statsfiles(cnavgdir):
    statsfiles = glob.glob(cnavgdir + "/" + "HISTORY_STATS*")
    sys.stderr.write("statsfiles: %s\n" % (str(statsfiles)))
    mystats = np.array([])
    mysims = []
    runlens = []
    for statsfile in statsfiles:
        sim = int(re.match(".*HISTORY_STATS_(\d+)", statsfile).group(1))
        mysims.append(sim)
        historystats = np.fromregex(statsfile, r"\((\d+), (\d+)\)\t(\d+)\t(\d+)\t(\d+)\t(\d+)", dtype=int)
        runlens.append(historystats.shape[0])
    runlen = max(runlens)
    for sim in mysims:
        statsfile = os.path.join(cnavgdir, "HISTORY_STATS_%d" % sim)
        historystats = np.fromregex(statsfile, r"\((\d+), (\d+)\)\t(\d+)\t(\d+)\t(\d+)\t(\d+)", dtype=int)
        if mystats.size == 0:
            mystats = np.zeros(((max(mysims) + 1) * runlen, historystats.shape[1] + 1), dtype=int)
        hids = np.array(range(historystats.shape[0])) + sim * Global_BINWIDTH
        i = sim * runlen
        mystats[i : i + runlen, :] = np.hstack((np.atleast_2d(hids).T, historystats))
    return mystats

    def parse(self,xmlHeaderFile,quick=True):
        """
Parse the usefull part of the xml header,
stripping time stamps and non ascii characters
"""
        lightXML = StringIO.StringIO()
        #to strip the non ascii characters
        t = "".join(map(chr, range(256)))
        d = "".join(map(chr, range(128,256)))
        
        if not quick:
            #store all time stamps in a big array
            timestamps = np.fromregex(
                xmlHeaderFile,
                r'<TimeStamp HighInteger="(\d+)" LowInteger="(\d+)"/>',
                float
                )
            xmlHeaderFile.seek(0)
            relTimestamps = np.fromregex(
                xmlHeaderFile,
                r'<RelTimeStamp Time="(\f+)" Frame="(\d+)"/>|<RelTimeStamp Frame="[0-9]*" Time="[0-9.]*"/>',
                float
                )
            xmlHeaderFile.seek(0)
            for line in xmlHeaderFile:
                lightXML.write(line.translate(t,d))
            
        else:
            #to strip the time stamps
            m = re.compile(
                r'''<TimeStamp HighInteger="[0-9]*" LowInteger="[0-9]*"/>|'''
                +r'''<RelTimeStamp Time="[0-9.]*" Frame="[0-9]*"/>|'''
                +r'''<RelTimeStamp Frame="[0-9]*" Time="[0-9.]*"/>'''
                )
            
            for line in xmlHeaderFile:
                lightXML.write(''.join(m.split(line)).translate(t,d))
        lightXML.seek(0)
        self.xmlHeader = parse(lightXML)