예제 #1
0
def geninfo(tilename,ori,rec):



    '''
    read data from file
    '''
    
    
    
    oriFile = File(ori, mode='r')
    recFile = File(rec, mode='r')

    '''
    create dataframe ori file
    '''

    tic = time.perf_counter()
    dataori={}
    dataori["points"] = pd.DataFrame(oriFile.points["point"])
    dataori["points"].columns = (x.lower() for x in dataori["points"].columns)
    dataori["points"].loc[:, ["x", "y", "z"]] *= oriFile.header.scale 
    dataori["points"].loc[:, ["x", "y", "z"]] += oriFile.header.offset
    dataori["header"] = oriFile.header

    '''
    create dataframe rec file
    '''

    datarec={}
    datarec["points"] = pd.DataFrame(recFile.points["point"])
    datarec["points"].columns = (x.lower() for x in datarec["points"].columns)
    # rescale and offset
    datarec["points"].loc[:, ["x", "y", "z"]] *= recFile.header.scale 
    datarec["points"].loc[:, ["x", "y", "z"]] += recFile.header.offset
    datarec["header"] = recFile.header
    toc = time.perf_counter()
    print(f"data frame created in {toc - tic:0.4f} seconds")

   

    tdata=OrderedDict()

    # Header Information
    # version test
    o_version=oriFile.header.version
    r_version=recFile.header.version

    if o_version != r_version:
        version_test='Failed'
        tdata['Version'] = f'Ori - {o_version} Rec - {r_version}'
        tdata['Version Test'] = 'Failed'
        print(f"Version test Failed for {tilename}")
    else:
        version_test='Passed'
        tdata['Version'] = f'{o_version}'
        tdata['Version Test'] = 'Passed'
        print(f"Version test Passed for {tilename}")
    
    # Data Format ID testt
    o_pdrf = oriFile.header.data_format_id
    r_pdrf = recFile.header.data_format_id

    if o_pdrf != r_pdrf:
        tdata['PDRF'] = f'Ori-{o_pdrf} Rec - {r_pdrf}'
        tdata['PDRF Test'] = 'Failed'

    else:
        tdata['PDRF'] = f'{o_pdrf}'
        tdata['PDRF Test'] = 'Passed'


    # Global Engoding testt
    o_ge = oriFile.header.global_encoding
    r_ge = recFile.header.global_encoding

    if o_ge != r_ge:
        tdata['GlobalEncoding'] = f'Ori-{o_ge} Rec - {r_ge}'
        tdata['GlobalEncoding Test'] = 'Failed'

    else:
        tdata['GlobalEncoding'] = f'{o_ge}'
        tdata['GlobalEncoding Test'] = 'Passed'


    #test number of points
    o_len = len(dataori['points'])
    r_len = len(datarec['points'])
    if o_len != r_len:
        tdata['Number of points'] = f'Ori - {o_len} Rec - {r_len}'
        tdata['Number of Points Test'] = 'Failed'
        print(f"Number of points test Failed for {tilename}")
    else:
        len_test='Passed'
        tdata['Number of points'] = len(datarec['points'])
        tdata['Number of Points Test'] = 'Passed'
        #print(f"Number of points test Passed for {tilename}")

    
    #test points

    tic = time.perf_counter()

    x0=dataori['points']['x']
    x1=datarec['points']['x']

    y0=dataori['points']['y']
    y1=datarec['points']['y']

    z0=dataori['points']['z']
    z1=datarec['points']['z']



    #print(x0==x1)
    #print(y0==y1)
    #print(z0==z1)
    if x0.all()!=x1.all() and y0.all()!=y1.all() and z0.all()!=z1.all():
        tdata['Points Test'] = 'Failed'
        toc = time.perf_counter()
        print(f"Points test Failed - {toc - tic:0.4f} seconds")
    else:
        print(f'{tilename} XYZ matched')
        tdata['Points Test'] = 'Passed'
        toc = time.perf_counter()
        print(f"Points test Passed - {toc - tic:0.4f} seconds")


    #test gpstime
    r_gps = [min(datarec['points']['gps_time']),max(datarec['points']['gps_time'])]
    o_gps = [min(dataori['points']['gps_time']),max(dataori['points']['gps_time'])]

    if o_gps != r_gps:
        gps_test='Failed'
        tdata['GPS times'] = f'Ori - {o_gps} Rec - {r_gps}'
        tdata['GPS Test'] = 'Failed'
        print(f"GPS Times test Failed for {tilename}")
    else:
        gps_test='Passed'
        tdata['GPS times'] = r_gps
        tdata['GPS Test'] = 'Passed'
        #print(f"GPS Times test Passed for {tilename}")

    # returns test
    o_returns=oriFile.get_return_num()
    r_returns=recFile.get_return_num()

    nr0=oriFile.get_num_returns()
    nr1=recFile.get_num_returns()    


    #nr1=datarec['points']['number of returns']

    if o_returns.all() != r_returns.all():
        returns_test='Failed'
        tdata['Returns'] = f'Ori - {o_returns} Rec - {r_returns}'
        tdata['Returns Test'] = 'Failed'
        print(f"Point Returns test Failed for {tilename}")
    else:
        returns_test='Passed'
        tdata['Returns'] = f'{o_returns[1],nr0[1]}'
        tdata['Returns Test'] = 'Passed'        
        print(f"Point Returns test Passed for {tilename}")
        ##returns=[i for i, j in zip(o_returns, r_returns) if i != j]
        #print(returns)
    
    # Intensity test
    r_intensity=[min(datarec['points']['intensity']),max(datarec['points']['intensity'])]
    o_intensity=[min(dataori['points']['intensity']),max(dataori['points']['intensity'])]
    
    if o_intensity != r_intensity:
        intensity_test='Failed'
        tdata['Intensity'] = f'Ori - {o_intensity} Rec - {r_intensity}'
        tdata['Intensity Test'] = 'Failed'
        print(f"Intensity test Failed for {tilename}")
    else:
        intensity_test='Passed'
        tdata['Intensity'] = f'{o_intensity}'
        tdata['Intensity Test'] = 'Passed'
        #print(f"Intensity test Passed for {tilename}")

    # Scale test
    o_scale=oriFile.header.scale
    r_scale=recFile.header.scale
    #print(o_offscale,r_offscale)
    if o_scale != r_scale:
        tdata['Scale']=f'Ori-{o_scale} Rec - {r_scale}'
        tdata['Scale Test'] = 'Failed'
        print(f"Scale test Failed for {tilename}")
    else:
        tdata['Scale']=f'{o_scale}'
        tdata['Scale Test'] = 'Passed'
        #print(f"Offset_Scale test Passed for {tilename}")
 
    return(True,tdata,'None')
예제 #2
0
flag_byte = inFile.get_flag_byte()
print("flag_byte shape",flag_byte.shape)

pt_ret_count = inFile.point_return_count()
print("type of point return count", type(pt_ret_count))

ret_num = inFile.get_return_num()
print("ret_num shape",ret_num.shape)
print("ret_num shape 100",ret_num[100].shape)
print("First returned number",ret_num[0],"\n")
print("First returned number",ret_num[0],"\n")
unique_elements, counts_elements = np.unique(ret_num, return_counts=True)
print("Frequency of unique values of the said array:")
print(np.asarray((unique_elements, counts_elements)),"\n")

num_returns = inFile.get_num_returns()
print("num_returns shape",num_returns.shape)

print("First number of returns:",num_returns[0])
unique_elements, counts_elements = np.unique(num_returns, return_counts=True)
print("Frequency of unique values of the said array:")
print(np.asarray((unique_elements, counts_elements)))

src_ids = inFile.get_pt_src_id()
print("First number of returns:",num_returns[0])
unique_elements, counts_elements = np.unique(src_ids, return_counts=True)
print("Frequency of", "source ids", "of the said array:")
print(np.asarray((unique_elements, counts_elements)))

#get_scan_dir_flag()