fileList=[]

if not os.path.exists(file_dir):

print('Wrong path!')

return

# get file list

for root, dirs, files in os.walk(file_dir, topdown=False):

for name in files:

fileFullPath=os.path.join(root, name)

fileList.append(fileFullPath)

rawDataFolderName = 'velodyne'

TargetFolderName = 'SphericalRing'

rawDataDir = os.path.join(strDataBaseDir, strSequence, rawDataFolderName)

rawDataList = GetFileList(os.path.join(strDataBaseDir, strSequence))

rawDataList = [oneFile for oneFile in rawDataList if oneFile[(len(oneFile)-3):len(oneFile)]=='bin']

nFramesInSequence = len(rawDataList)

nFiles = Frames.shape[0]

for iData in range(nFiles ):

fileName = str(Frames[iData]).zfill(6) + '.bin'

rawFileFullPath = os.path.join(rawDataDir, fileName)

PC = np.fromfile(rawFileFullPath, dtype=np.float32, count=-1).reshape([-1,4])

# process

SphericalRing, GridCounter = ProjectPC2SphericalRing(PC)

baseDir=os.path.dirname(os.path.dirname(rawFileFullPath))

targetDir=os.path.join(baseDir,TargetFolderName)

isFolder = os.path.exists(targetDir)

if not isFolder:

os.makedirs(targetDir)

fileName=os.path.basename(rawFileFullPath)+'.mat'

targetFullPath=os.path.join(targetDir,fileName)

io.savemat(targetFullPath, {'SphericalRing':SphericalRing, 'GridCounter':GridCounter})

print(strSequence, ':', nFramesInSequence, ':', Frames[iData], '\n', targetFullPath)

oriDataBaseDir = '/media/rain/Win10_H/KITTI_odometry/velodyne/sequences/'

curDataBaseDir = '/media/rain/Win10_F/KITTI_odometry/velodyne/sequences/'

rawDataFolderName = 'velodyne'

oriRawDataDir = os.path.join(oriDataBaseDir, strSequence, rawDataFolderName)

curRawDataDir = os.path.join(curDataBaseDir, strSequence, rawDataFolderName)

nFiles = Frames.shape[0]

for iData in range(nFiles ):

fileName = str(Frames[iData]).zfill(6) + '.bin'

oriRawFileFullPath = os.path.join(oriRawDataDir, fileName)

curRawFileFullPath = os.path.join(curRawDataDir, fileName)

PC = np.fromfile(oriRawFileFullPath, dtype=np.float32, count=-1).reshape([-1,4])

PC_ = CorrectPC(PC[:,0:3])

PC_ = np.c_[PC_, PC[:,3]]

PC_ = PC_.flatten()

with open(curRawFileFullPath, 'wb') as f:

f.write(PC_)

print(strSequence, ':', iProc, ':', iThread, ':', nFiles, ':', iData, ':', '\n', curRawFileFullPath)

DataFolderName = 'SphericalRing'

SphericalRingDir = os.path.join(strDataBaseDir, strSequence, DataFolderName)

nFrames = subFrames.shape[0]

# get all spherical rings and grid counters

SphericalRings = np.zeros((nFrames, nLines, ImgW-CropWidth_SphericalRing, len(Channels4AE)), dtype=np.float32)

GridCounters = np.zeros((nFrames, ImgH, ImgW), dtype=np.int8)

for iData in range(nFrames):

fileName = str(subFrames[iData]).zfill(6) + '.bin.mat'

fileFullPath = os.path.join(SphericalRingDir, fileName)

mat = io.loadmat(fileFullPath)

SphericalRing = mat['SphericalRing']

GridCounter = mat['GridCounter']

SphericalRings[iData,:,:,:] = np.array(SphericalRing[0:nLines, 0:ImgW-CropWidth_SphericalRing, Channels4AE], dtype=np.float32)

GridCounters[iData,:,:] = GridCounter

print('finished loading data, predicting...')

# predict

RespondImgs = np.array(RespondLayer.predict(SphericalRings), dtype=np.float32)

print('finished predicting, extracting keyPts...')

RespondsList = []

RespondsList.append(RespondImgs)

KeyPtFolderName = 'KeyPts'

FeaturesFolderName = 'Features'

rawDataList = GetFileList(os.path.join(strDataBaseDir, strSequence))

rawDataList = [oneFile for oneFile in rawDataList if oneFile[(len(oneFile)-3):len(oneFile)]=='bin']

nFramesInSequence = len(rawDataList)

nDatas = len(FrameList)

for iData in range(nDatas):

iFrame = FrameList[iData]

SphericalRing = SphericalRings[iData,:,:,:]

GridCounter = GridCounters[iData,:,:]

RespondImg = RespondImgs[iData,:,:,:]

# extract key points

KeyPts, KeyPixels, PlanarPts = GetKeyPtsByAE(SphericalRing, GridCounter, RespondImg)

# extend key points for the final pose refine

ExtendedKeyPts = ExtendKeyPtsInShpericalRing(SphericalRing, GridCounter, KeyPixels)

# save key points

keyPtDir = os.path.join(strDataBaseDir, strSequence, KeyPtFolderName)

isFolder = os.path.exists(keyPtDir)

if not isFolder:

os.makedirs(keyPtDir)

fileName = str(iFrame).zfill(6)+'.bin.mat'

ketPtFullPath = os.path.join(keyPtDir, fileName)

io.savemat(ketPtFullPath, {'KeyPts':KeyPts, 'ExtendedKeyPts':ExtendedKeyPts, 'PlanarPts':PlanarPts})

print(strSequence, ':', nFramesInSequence, ':', iFrame, '\n', ketPtFullPath)

manager = Manager()

nThreads = 10

if iOption == 2:

os.environ["CUDA_VISIBLE_DEVICES"] = "0"

import tensorflow as tf

from keras.backend.tensorflow_backend import set_session

config = tf.ConfigProto()

config.gpu_options.per_process_gpu_memory_fraction = 0.5

set_session(tf.Session(config=config))

import keras

from keras.models import load_model

RespondLayer = load_model(strRespondNetModelPath)

for iSequence in range(0, 11, 1):

strSequence=str(iSequence).zfill(2)

dirSequence=os.path.join(strDataBaseDir, strSequence)

rawDataList = GetFileList(dirSequence)

rawDataList = [oneFile for oneFile in rawDataList if oneFile[(len(oneFile)-3):len(oneFile)]=='bin']

nFiles = len(rawDataList)

AllFrames = np.arange(0, nFiles, 1, dtype=np.int32)

# divide the whole frames into several parts

# because going to put a whole part data into memory for opt2

nProcs = 1

if iOption == 2:

nMaxFilesPerProc = 600

nProcs = int(nFiles/nMaxFilesPerProc) + 1

nFilesPerProc = int(nFiles/nProcs)

for iProc in range(nProcs):

iStartProcFrame = iProc*nFilesPerProc

iEndProcFrame = (iProc+1)*nFilesPerProc

if iProc+1 == nProcs:

iEndProcFrame = nFiles

subFrames = AllFrames[slice(iStartProcFrame, iEndProcFrame, 1)]

nSubFrames = subFrames.shape[0]

flags4MultiProc = manager.list([])

FrameLists = []

for iList in range(nThreads):

slices = slice(iList,nSubFrames,nThreads)

FrameLists.append(subFrames[slices])

flags4MultiProc.append(0)

if iOption == 2:

SphericalRings, GridCounters, RespondsList = GetAllRespondImgs(strSequence, subFrames, RespondLayer)

RespondImgs = RespondsList[0]

SphericalRingLists = []

GridCounterLists = []

RespondImgLists = []

for iList in range(nThreads):

slices = slice(iList,nSubFrames,nThreads)

SphericalRingLists.append(SphericalRings[slices,:,:,:])

GridCounterLists.append(GridCounters[slices,:,:])

RespondImgLists.append(RespondImgs[slices,:,:])

# BatchProjection(rawDataLists[0], 0, flags4MultiProc)

for iThread in range(nThreads):

if iOption == 1:

t = Process(target = BatchProjection, args=(strSequence, FrameLists[iThread], iProc, iThread, flags4MultiProc))

if iOption == 2:

t = Process(target = BatchGetKeyPts, args=(strSequence, FrameLists[iThread], SphericalRingLists[iThread], GridCounterLists[iThread],

RespondImgLists[iThread], iProc, iThread, flags4MultiProc))

# BatchGetKeyPts(strSequence, FrameLists[iThread], SphericalRingLists[iThread], GridCounterLists[iThread],

# RespondImgLists[iThread], iProc, iThread, flags4MultiProc)

if iOption == 3:

t = Process(target = BatchCorrectPC, args=(strSequence, FrameLists[iThread], iProc, iThread, flags4MultiProc))

t.start()

while sum(flags4MultiProc)<nThreads:

sleep(1)