Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

import argparse import os,glob,sys,yaml,cv2 import time,datetime import numpy as np…

  1. User

    import argparse import os,glob,sys,yaml,cv2 import time,datetime import numpy as np import torch import torch.nn as nn import torch.nn.parallel import torch.backends.cudnn as cudnn import torch.optim as optim import torch.nn.functional as F import torch.utils.data from thop import profile INVALID_DISPARITY_F32 = 0.-300. INVALID_DISPARITY_U16 = 32768

    from util import save_checkpoint,AverageMeter,save_float_to_colormap,normerWrong,normer,normerImageNet,resizer,constantNorm

    from lightStereo.lightstereo_refine import LightStereo

    from lightStereo.lightstereo import LightStereo

    def dispFloatToUint16(dispFOrig, ratio=1.): ''' disparity range from -300 to -0 is currently not suppoted for read/write to png file ''' dispF = dispFOrig.copy()ratio dispInvMsk=(dispF<=INVALID_DISPARITY_F32ratio) dispValMsk=(dispF>INVALID_DISPARITY_F32*ratio) dispF[dispValMsk] *= 128. dispF[dispInvMsk] = INVALID_DISPARITY_U16 dispU16 = dispF.astype(np.uint16) return dispU16

    def convert_relu_to_relu6(model): for child_name, child in model.named_children(): if isinstance(child, (nn.ReLU, nn.LeakyReLU)): #print(child_name) setattr(model, child_name, nn.ReLU6(inplace=True)) else: convert_relu_to_relu6(child)

    gaussian blur

    def gaussBlurCore(img, ksize=(3,3), sigma=0.35): kw = int(ksize[0]) kh = int(ksize[1]) blurImg = cv2.GaussianBlur(img, (kw,kh), sigma) return blurImg

    def gaussBlur(left, right): left, right = left.copy(), right.copy() left, right = left, right

    left     = gaussBlurCore(left)
    left,right   = left, right
    return left, right
    

    def colorTransfer(Isrc, Iref): Is = Isrc.copy() Ir = Iref.copy() #plt.imshow(Ir[...,::-1])
    #plt.show() #plt.imshow(Is[...,::-1]) #plt.show() #BGR->LAB valid = ((Iref[:,:,0]>0) & (Iref[:,:,1]>0) & (Iref[:,:,2]>0)) LabIs = cv2.cvtColor(Is,cv2.COLOR_BGR2LAB) LabIr = cv2.cvtColor(Ir,cv2.COLOR_BGR2LAB) #mean、std Is_means = [0, 0, 0] Ir_means = [0, 0, 0] Is_stdevs = [0, 0, 0] Ir_stdevs = [0, 0, 0] LabIs = LabIs.astype(np.float32)/255. LabIr = LabIr.astype(np.float32)/255. for i in range(3): Is_means[i] += LabIs[:,:,i].mean() Ir_means[i] += LabIr[:,:,i][valid].mean() Is_stdevs[i] += (LabIs[:,:,i].std() + 1e-9) Ir_stdevs[i] += (LabIr[:,:,i][valid].std() + 1e-9) thresh = [a/b for a,b in zip(Ir_stdevs,Is_stdevs)] LabIt = thresh*(LabIs -Is_means) + Ir_means

    # [0-255]
    LabIt = (LabIt*255.)
    LabIt *= (LabIt>0)
    LabIt = (LabIt * (LabIt<=255) + 255 * (LabIt>255)).astype(np.uint8)
    
    #show
    It = cv2.cvtColor(LabIt,cv2.COLOR_LAB2BGR)
    #plt.imshow(It)
    #plt.show()
    
    return It
    

    def getYamlCfg(fn='models/configModelTest.yaml'): f = open(fn, 'r', encoding='utf-8') cfg = f.read() content = yaml.load(cfg, Loader=yaml.FullLoader) return content

    def initModels(content, modelFolder='models', args=None): numOfModels = len(list(content.keys())) #importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        importedFolder = __import__(content[modelName]['modelFolder'])
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'], args=args)
        break
    
    return singleModel['classInst']
    

    def initModelsBug(content, modelFolder='models'): numOfModels = len(list(content.keys())) importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'])
        break
    
    return singleModel['classInst']
    

    def loadPretrain(model, pretrained, strict=False): oldCkpt = torch.load(pretrained) if pretrained.find('.tar')>=0: oldCkpt = oldCkpt['state_dict'] newCkpt = {} for k in oldCkpt.keys(): newCkpt[k.replace('module.','')] = oldCkpt[k] model.load_state_dict(newCkpt, strict=strict) return model

    Training settings

    parser = argparse.ArgumentParser(description='Stereo training...') parser.add_argument('--data_parent_path', type=str, default='/home/notebook/data/group/xizhong_xxz/', help="location to save models") parser.add_argument('--data_config_path', type=str, default='./configs/configDatasetMultiscale.yaml', help="location to save models") parser.add_argument('--model_config_path', type=str, default='./configs/configModel.yaml', help="location to save models") parser.add_argument('--loss_config_path', type=str, default='./configs/configLoss.yaml', help="location to save models") parser.add_argument('--save_path', type=str, default='./rectify', help="location to save models") parser.add_argument('--use_gru_refine', type=int, default=0, help="if use gru refine for disp output") parser.add_argument('--useBackboneV2', type=int, default=0, help='1 use mobilenet') parser.add_argument('--att_relu6', type=int, default=0, help='1 use relu6 for att module') parser.add_argument('--convex_up', type=int, default=0, help='1 use convex upsample') parser.add_argument('--transAtt', type=int, default=0, help='1 use self att') parser.add_argument('--agg_blocks', default=[8,16,32], metavar='N', nargs='*', help='set the block number for each stage') parser.add_argument('--pretrained_Backbone', type=int, default=1, help='1 use pretrained backbone to extractor feature') parser.add_argument('--sample_tail', type=int, default=0, help="if add a tail refinement for output quantize") parser.add_argument('--use_mono', type=int, default=0, help="if use mono optimize stereo")

    parser.add_argument('--useResNet', type=int, default=0, help='use resnet as backbone') parser.add_argument('--validateOnly', type=int, default=0, help='do validation only. Default=0') parser.add_argument('--warmup', type=int, default=0, help='do warmup training or not, Default=0') parser.add_argument('--abnormAug', type=int, default=0, help='do abnormal augmenation such as thin plate transform or diagonal epipolar transform') parser.add_argument('--eraseAug', type=int, default=0, help='do erasing augmenation') parser.add_argument('--occAug', type=int, default=0, help='do occlusion augmentation in right image branch') parser.add_argument('--defocusAug', type=int, default=0, help='do blur augmentation in all image branches') parser.add_argument('--gradLoss', type=int, default=0, help='use gradient loss for supervision') parser.add_argument('--normLoss', type=int, default=0, help='use normal loss for supervision') parser.add_argument('--smtLoss', type=int, default=0, help='use smoothness loss for self-supervision') parser.add_argument('--use_dn', type=int, default=0, help='0 for bn, 1 for dn') parser.add_argument('--mobile', type=int, default=0, help='0 for bn, 1 for mobile') parser.add_argument('--use_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--use_refine_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--backbone_relu6_only', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--noNormInput', type=int, default=0, help='normalize input to 0.0 ~ 1.0') parser.add_argument('--rgbOrder', type=int, default=0, help='0 for bgr, 1 for rgb') parser.add_argument('--normGT', type=int, default=0, help='normalize GT to 0.0 ~ 1.0') parser.add_argument('--ada_sigma', type=int, default=0, help='0 for fixed sigma, 1 for adaptive sigma') parser.add_argument('--depth_wise', type=int, default=0, help='depth wise conv for decoder') parser.add_argument('--ada_cost', type=int, default=1, help='0 for fixed cost, 1 for adaptive cost') parser.add_argument('--simple_refine', type=int, default=0, help='1 for simple refiner, 0 for warp refiner') parser.add_argument('--rightDown2x', type=int, default=0, help='1 for right image plane down 2x, 0 for no downscale') parser.add_argument('--clipGrad', type=int, default=0, help='use gradient clipping for training') parser.add_argument('--clip', type=float, default=2.1, help='clipping range') parser.add_argument('--skyFill', type=int, default=1, help='fill sky area with disparity 0.0 with semantic label') parser.add_argument('--use_refine', type=int, default=0, help='use refinement blocks') parser.add_argument('--refine_stages', type=int, default=2, help='use refinement blocks') parser.add_argument('--warp_feature', type=int, default=0, help='warp feature or original image') parser.add_argument('--wRec', type=float, default=0.0, help='gradient loss weight') parser.add_argument('--proj_ch', type=int, default=3, help='channels to reconsrtuct') parser.add_argument('--pre_scale', type=float, default=0.666667, help='pre-scale') parser.add_argument('--cat2Fuse', type=int, default=0, help='costs cat to fuse') parser.add_argument('--trainSceneFlowOnly', type=int, default=0, help='train scene flow dataset only') parser.add_argument('--wGrad', type=float, default=0.5, help='gradient loss weight') parser.add_argument('--wSmt', type=float, default=0.5, help='smooth loss weight') parser.add_argument('--inconsistAug', type=int, default=0, help='inconsistancy augmentation for LR pairs') parser.add_argument('--imageNetInputNorm', type=int, default=0, help='inputs normalized like in imagenet') parser.add_argument('--constantNorm', type=int, default=0, help='inputs normalized to [-1, 1]') parser.add_argument('--useTransformer', type=int, default=0, help='use transformer blocks') parser.add_argument('--correctCorr', type=int, default=0, help='use correct correlation') parser.add_argument('--copyPaste', type=int, default=1, help='use copy paste tech.') parser.add_argument('--zeroBlack', type=int, default=0, help='black area filled with zero when normalizing.') parser.add_argument('--zeroInvalidGt', type=int, default=0, help='black area filled with zero gt.')

    parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range") #parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range")

    parser.add_argument('--shift', type=int, default=0, help='random shift of left image. Default=0') #shift value must be zero for cost volume aggregation (soft argmin) based network parser.add_argument('--crop_height', type=int, default=640, help="crop height") parser.add_argument('--crop_width', type=int, default=768, help="crop width") parser.add_argument('--resume', type=str, default='', help="resume from saved model") parser.add_argument('--start_epoch', type=int, default=0, help='the epoch to resume training') parser.add_argument('--pretrained', dest='pretrained', default=None, help='path to pre-trained model')

    parser.add_argument('--batch_size', type=int, default=8, help='training batch size') parser.add_argument('--val_batch_size', type=int, default=8, help='testing batch size') parser.add_argument('--workers', type=int, default=32, help='number of threads') parser.add_argument('--nEpochs', type=int, default=64, help='number of epochs to train for') parser.add_argument('--solver', default='adam',choices=['adam','sgd'], help='solver algorithms') parser.add_argument('--lr', type=float, default=0.0008, help='Learning Rate. Default=0.001') parser.add_argument('--lr_decay', type=float, default=0.5, help='Learning Rate descending rete. Default=0.5')

    ''' Attention: milestones should be ignored(keep unchanged), since it's adapted to nEpochs in the latter main function ''' #####parser.add_argument('--milestones', default=[14,28,42,56], metavar='N', nargs='', help='epochs at which learning rate is divided by 2')
    parser.add_argument('--milestones', default=[10,20,30,40,50,60], metavar='N', nargs='
    ', help='epochs at which learning rate is divided by 2') #parser.add_argument('--milestones', default=[13,23,33,43,53,63], metavar='N', nargs='*', help='epochs at which learning rate is divided by 2')

    #parser.add_argument('--weight_decay', '--wd', default=4e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--weight_decay', '--wd', default=1e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--bias_decay', default=0, type=float, metavar='B', help='bias decay') parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum for sgd, alpha parameter for adam') parser.add_argument('--beta', default=0.999, type=float, metavar='M', help='beta parameter for adam')

    ''' ascending order means use loss.sum()/batchSize, which is map level average descending order means use loss.mean(), which is pixel level average ''' #parser.add_argument('--multiscale_weights', '-w', default=[0.005,0.01,0.02,0.08,0.32], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) #parser.add_argument('--multiscale_weights', '-w', default=[0.32,0.08,0.02,0.01,0.005], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) parser.add_argument('--multiscale_weights', '-w', default=[1./3, 2./3, 1., 1., 1.], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6'))

    parser.add_argument('--seed', type=int, default=2022, help='random seed to use. Default=123')

    parser.add_argument('--print_freq', '-p', default=50, type=int, metavar='N', help='print frequency') parser.add_argument('--save_freq', '-s', default=5, type=int, metavar='N', help='save checkpoint frequency') device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    def main():

    args = parser.parse_args()
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
    print('=> get test data pairs')
    # args.data_path="/home/notebook/data/group/liulibo/stereoProject/rectify/bars/"
    # args.data_path="/home/notebook/data/group/liulibo/MiDaS/langan_refine_data/"
    args.data_path="/home/notebook/data/group/Ruby/langan_datasets/langan/"
    
    args.flip_LR=0
    args.useMinMax=0
    lists  =[args.data_path+file  for file in os.listdir(args.data_path)  if(("left"  in file  or "master"  in file)  and "disp"  not in file)]
    total  = len(lists)
    print(total)
    #pause
    
    print('=> get models from configuration file')
    content = getYamlCfg(fn='configs/configModelTest.yaml')
    model = LightStereo(parser)
    model = model.to(device).eval()
    # model   = loadPretrain(model, "./checkpoint/refiner_finetune_20240918/model_best.pth.tar", strict=False)
    model   = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
    print('=> infer')
    count=0
    # for idx in range(total):
    for file in os.listdir(args.data_path):  
        if(("left"  in file  or "master"  in file)):
            if "Disp"   in file:
                continue
            try:
                srcLFn    = args.data_path+file
                srcRFn    = srcLFn.replace('left','right').replace('master', 'slave')
                print(srcLFn)
                print(srcRFn)
                lImg      = cv2.imread(srcLFn,1)
                rImg      = cv2.imread(srcRFn,1)
                h,w,c=lImg.shape
                hh,ww,cc=rImg.shape
                lMask     = ((lImg[:,:,0]==0) & (lImg[:,:,1]==0) & (lImg[:,:,2]==0)).astype(np.uint8)
            except:
                continue
            if args.flip_LR>0:
                lImg  = lImg[:,::-1,:]
                rImg  = rImg[:,::-1,:]
                lMask = lMask[:,::-1]
    
            rszH,rszW = lImg.shape[0],lImg.shape[1]
            lImg,rImg = resizer(lImg,rImg,args)
    
            # if args.rgbOrder > 0:
            #     lImg= lImg[:,:,::-1].copy()
            #     rImg= rImg[:,:,::-1].copy()
            # if args.imageNetInputNorm <= 0:
            #     imgPair   = normer(lImg, rImg)
            # else:
            #     if args.constantNorm:
            #         imgPair   = constantNorm(lImg, rImg)
            #     else:
            imgPair   = normerImageNet(lImg, rImg)
            
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():        
                output= model(imgPairTs)
    
            if isinstance(output, list):
                output    = output[-1].squeeze().cpu().numpy()
            else:
                output    = output.squeeze().cpu().numpy()
            if args.flip_LR>0:
                output    = output[:,::-1]
                lMask     = lMask[:,::-1]
    
            outH,outW = output.shape[0],output.shape[1]
            scaleDisp = rszW * 1. / outW
    
            output    = cv2.resize(output, (rszW,rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
            #print(output.min())
    
            # dispU16   = dispFloatToUint16(output, ratio=3)
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/langan/'
            cv2.imwrite(output_path +'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
    
            # print(args.save_path)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp_gray').replace('master','gru_leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp').replace('master','gru_leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp_gray').replace('master','leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp').replace('master','leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
        
    

    if name == 'main': main()

    对于这个代码,在不改变基本功能和结构的前提下,读取txt以得到左图和右图,对于第i行,左图满足i%2=0,右图满足i%2=1

  2. Assistant

    要读取一个文本文件并根据行索引来提取左图和右图的文件名,可以在主函数中对 args.data_path 进行修改,使其从一个指定的文本文件中读取图像路径。假设你的文本文件名为 image_paths.txt,其中左图和右图的文件名依次排列,左图在偶数行,右图在奇数行。

    下面是修改后的 main() 函数的核心部分:

    def main():
        args = parser.parse_args()
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
        print('=> get test data pairs')
        
        # 从指定的文本文件中读取图像
        args.data_path = 'path/to/image_paths.txt'  # 替换为你的文件路径
        with open(args.data_path, 'r') as f:
            lines = [line.strip() for line in f.readlines()]
    
        total = len(lines)
        print("Total image pairs:", total // 2)  # 每对图片需要两行,左图和右图
        
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        
        count = 0
        for i in range(0, total, 2):  # 每次取2行
            srcLFn = lines[i]         # 偶数行,左图
            srcRFn = lines[i + 1]     # 奇数行,右图
            
            print(f'Processing left image: {srcLFn}')
            print(f'Processing right image: {srcRFn}')
            
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
            
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} and {srcRFn}')
                continue
            
            # 继续处理图像的其他部分,保持不变
            h, w, c = lImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
            
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
            imgPair = normerImageNet(lImg, rImg)
            
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
            
            # 处理预测结果并保存
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/langan/'
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    
    if __name__ == '__main__':
        main()
    

    修改的关键点:

    1. 读取文件: 使用标准 Python 文件操作打开和读取指定的文本文件。
    2. 行索引处理: 遍历行时每次增加 2,以便左图和右图的文件名能够正确配对。
    3. 错误处理: 加入对图像读取失败的处理以避免程序中断。

    确保在你的文本文件 image_paths.txt 中每一行都正确指向左图和右图的路径,左图的路径在偶数行,右图的路径在奇数行。这样代码便能根据文件内容进行数据对的读取和处理。

  3. User

    import os import glob

    def split_image_paths_to_txt(input_folder, file_extension, output_folder): # 确保输出文件夹存在 os.makedirs(output_folder, exist_ok=True)

    # 获取指定后缀的所有图像文件路径
    image_paths = glob.glob(os.path.join(input_folder, f'*{file_extension}'))
    
    # 分成n份
    num_files = len(image_paths)
    n = 10
    split_size = max(1, num_files // n)  # 至少写入一个文件
    
    for i in range(n):
        start_index = i * split_size
        end_index = start_index + split_size if i < 9 else num_files  # 最后一个文件包含余下的所有内容
        portion = image_paths[start_index:end_index]
        
        # 将每一部分写入对应的TXT文件
        output_file = os.path.join(output_folder, f'output_{i+1}.txt')
        with open(output_file, 'w') as f:
            for path in portion:
                f.write(path + '\n')
                
    print(f"成功将图像路径分成{n}份并写入到 '{output_folder}' 文件夹中。")
    

    if name == 'main': # 输入参数 input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono' # 替换为你的图像文件夹路径 file_extension = '_idx0.png' # 或者其他后缀,如 '.png' output_folder = './' # 替换为你想保存输出文件的文件夹路径

    split_image_paths_to_txt(input_folder, file_extension, output_folder)
    

    修改这个代码,不改变代码功能和结构的前提下,使得可以分别读取两种后缀,并交替写入txt,使得‘_left’在偶数行,‘_right’在奇数行

  4. Assistant

    要修改原有代码以便交替写入带有 _left 和 _right 后缀的图像路径,并确保 _left 的路径在偶数行而 _right 的路径在奇数行,我们可以按以下方式调整代码:

    1. 使用 glob 获取两种后缀的文件路径。
    2. 将 _left 和 _right 的路径交替写入同一个输出文件。

    以下是修改后的代码示例:

    import os
    import glob
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
        
        # 合并数组以交替写入
        combined_paths = []
        
        # 使用 zip_longest 结合 itertools 确保两个列表同时迭代
        from itertools import zip_longest
        for left_path, right_path in zip_longest(left_image_paths, right_image_paths):
            if left_path:
                combined_paths.append(left_path)   # 偶数行
            if right_path:
                combined_paths.append(right_path)  # 奇数行
    
        # 将写入内容写入文件
        output_file = os.path.join(output_folder, 'image_paths.txt')
        with open(output_file, 'w') as f:
            for path in combined_paths:
                f.write(path + '\n')
                    
        print(f"成功将图像路径交替写入到 '{output_file}' 文件中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder)
    

    主要修改点:

    1. 两个后缀的路径分开获取: 分别获取 _left 和 _right 后缀的图像路径。

    2. 交替写入文件: 使用 itertools.zip_longest 实现交替写入,这可以有效地处理两种路径数量不等的情况。

    3. 合并文件路径写入到单个输出文件: 所有路径按照顺序写入同一个 image_paths.txt 文件,以确保 _left 的路径出现在偶数行,_right 的路径出现在奇数行。

    这样,你的输出文件将满足每行交替的要求。文件的偶数行将包含左图路径,奇数行将包含右图路径。

  5. User

    需要分成十个txt

  6. Assistant

    要将 _left 和 _right 后缀的图像路径交替写入到十个不同的文本文件中,并确保 _left 的路径在偶数行,_right 的路径在奇数行,可以通过以下修改实现。每个文本文件都会写入相应数量的路径,确保每个文件都有一个预先指定的数量(例如,使用整除逻辑来分配路径)。

    以下是修改后的代码:

    import os
    import glob
    from itertools import zip_longest
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
        
        # 合并数组以交替写入
        combined_paths = []
        
        for left_path, right_path in zip_longest(left_image_paths, right_image_paths):
            if left_path:
                combined_paths.append(left_path)   # 偶数行
            if right_path:
                combined_paths.append(right_path)  # 奇数行
    
        # 计算每个文件应该包含多少路径
        total_paths = len(combined_paths)
        n = 10  # 需要分成的文件数量
        split_size = max(1, total_paths // n)  # 每个文件至少写入一个路径
        
        # 将路径分成n份,并写入对应的TXT文件
        for i in range(n):
            start_index = i * split_size
            end_index = start_index + split_size if i < n-1 else total_paths  # 最后一个文件包含余下的所有内容
            portion = combined_paths[start_index:end_index]
            
            # 将每一部分写入对应的TXT文件
            output_file = os.path.join(output_folder, f'output_{i+1}.txt')
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
                    
        print(f"成功将图像路径分成{n}份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder)
    

    主要修改点:

    1. 保留交替逻辑: 依然使用 zip_longest 来交替收集 _left 和 _right 的路径列表。

    2. 分成十个文本文件: 将所有路径分成十个部分,计算每个文件应该包含的路径数量。使用 split_size 变量确定每个文件的最大路径数目。

    3. 处理最后一个文件的剩余路径: 对于最后一个文件,确保它包含所有剩下的路径。

    这样,最终会在指定的输出文件夹中生成十个文本文件,每个文件将交替列出来自左侧和右侧的图像路径。

  7. User

    保证每个txt文件都是偶数行

  8. Assistant

    为了保证每个输出的文本文件都包含偶数行,我们需要确保每个文件包含相同数量的左图和右图路径。因此,我们将对路径进行分组,并且每一组中都包含相同数量的左图和右图路径。

    假设你希望每个文件都包含 m 行(每个文件需要包含的偶数行),那么每个文件将包含 m // 2 个 _left 路径和 m // 2 个 _right 路径。如果总路径数量无法整除 m,我们应该在最后的文件中处理剩余的路径。

    下面是修改后的代码示例:

    import os
    import glob
    from itertools import zip_longest
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, lines_per_file):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
    
        # 合并数组以交替写入
        combined_paths = []
        
        for left_path, right_path in zip_longest(left_image_paths, right_image_paths):
            if left_path:
                combined_paths.append(left_path)   # 偶数行
            if right_path:
                combined_paths.append(right_path)  # 奇数行
    
        # 确保每个文件都包含偶数行
        total_paths = len(combined_paths)
        n = total_paths // lines_per_file  # 需要分成的文件数量,根据传入的行数决定
        if total_paths % lines_per_file != 0:  # 如果不能整除,增加一个文件
            n += 1
    
        # 分组并写入文件
        for i in range(n):
            output_file = os.path.join(output_folder, f'output_{i + 1}.txt')
            start_index = i * lines_per_file
            end_index = start_index + lines_per_file
    
            # 从combined_paths中取出需要写入的部分
            portion = combined_paths[start_index:end_index]
    
            # 如果portion的路径数量不足以填充完整的行数,补充空行
            while len(portion) < lines_per_file:
                portion.append('')  # 填充空行
    
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
                    
        print(f"成功将图像路径分成{n}份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
        lines_per_file = 10  # 每个文件要写入的总行数,确保为偶数
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, lines_per_file)
    

    主要修改点:

    1. 引入 lines_per_file 参数: 这个参数决定了每个输出文件需要的总行数,确保它是偶数。

    2. 文件数量计算: 计算所需的文件数量,确保包括最终的未整除部分文件。

    3. 处理路径不足情况: 在写入文件时,如果指定的行数不足以填充整个文件,则使用空行进行填充,保证每个文件都有相同的行数。

    4. 输出路径: 文件名仍然使用 f'output_{i + 1}.txt' 格式,并写入按照规则交替排列的文件路径。

    通过这种方式,你可以确保每个输出的文本文件都包含偶数行,所有路径交替按照左图和右图的要求排列。

  9. User

    不指定lines_per_file,而是指定n个txt数量

  10. Assistant

    如果想要按指定的文本文件数量 n 来输出文件,并且确保每个文件包含偶数行,可以通过以下步骤进行调整:

    1. 计算左图和右图路径的数量。
    2. 计算要写入每个文本文件的路径数,确保每个文本文件的路径数量是偶数。
    3. 均匀分配路径到 n 个文本文件中,每个文件应该包含相同数量的 _left 和 _right 路径,并用空行填补。

    以下是修改后的代码实现:

    import os
    import glob
    from itertools import zip_longest
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
    
        # 合并数组以交替写入
        combined_paths = []
        
        for left_path, right_path in zip_longest(left_image_paths, right_image_paths):
            if left_path:
                combined_paths.append(left_path)   # 偶数行
            if right_path:
                combined_paths.append(right_path)  # 奇数行
    
        # 确保每个文件都包含偶数行
        total_paths = len(combined_paths)
    
        # 每个文件应包含的路径数(随机选择一个偶数)
        if total_paths % num_files == 0:
            paths_per_file = total_paths // num_files
        else:
            paths_per_file = total_paths // num_files + 1
    
        # 确保每个文件的路径数是偶数
        if paths_per_file % 2 != 0:
            paths_per_file += 1
    
        # 如果路径总数少于需要的行数,调整
        if paths_per_file > total_paths:
            paths_per_file = total_paths
    
        # 分组并写入文件
        current_path_index = 0
        for i in range(num_files):
            output_file = os.path.join(output_folder, f'output_{i + 1}.txt')
            portion = combined_paths[current_path_index:current_path_index + paths_per_file]
    
            # 如果portion的路径数量不足以填充完整的行数,补充空行
            while len(portion) < paths_per_file:
                portion.append('')  # 填充空行
    
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
    
            current_path_index += paths_per_file
            if current_path_index >= total_paths:
                break
    
        print(f"成功将图像路径分成{num_files}份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
        num_files = 10  # 指定要保存的文件数量
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files)
    

    主要修改点:

    1. 输入参数: 引入 num_files,这是用户希望生成的文本文件的数量。

    2. 路径分配: 计算每个输出文件应包含的路径数,并确保这个数目是偶数。

    3. 数组索引管理: 使用 current_path_index 变量跟踪当前已处理的路径,以便在分配到不同的文件时能够准确获取路径。

    4. 处理不足的路径情况: 当总路径数量少于指定的行数时,调整路径数以防止空文件的出现。

    这个代码能确保按照你的需求将路径均匀分配到指定数量的文本文件中,并保证每个文件的行数为偶数。

  11. User

    每个文件应包含的路径数应该适当均分

  12. Assistant

    谢谢你的反馈!为了保证在分割文件时能够适当地均分路径以确保每个输出文件的内容是合理的,我们需要保证每个文件中有左图路径和右图路径的平衡。以下是实现这些需求的更新代码。

    我们将确保:

    1. 每个文件的路径数量(paths_per_file)是偶数,并且在分配路径时尽量做到均分。
    2. 每个文件中的左图和右图数量相等。

    修改后的代码

    import os
    import glob
    from itertools import zip_longest
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
    
        # 合并数组以交替写入(保持左右图路径对应)
        combined_paths = []
        
        for left_path, right_path in zip_longest(left_image_paths, right_image_paths):
            if left_path:
                combined_paths.append(left_path)   # 偶数行
            if right_path:
                combined_paths.append(right_path)  # 奇数行
    
        total_paths = len(combined_paths)
    
        # 每个文件应该包含的路径数。确保为偶数并均匀分配
        paths_per_file = total_paths // num_files  # 整除得到基本的路径数
        if paths_per_file % 2 != 0:  # 确保是偶数
            paths_per_file -= 1
    
        # 处理路径数不足情况
        if paths_per_file <= 0:
            paths_per_file = 2  # 至少确保每个文件有两个路径
    
        # 确保每个文件可以获取相同数量的左图和右图
        paths_per_file //= 2  # 每个文件要包含的左图和右图数量
    
        current_path_index = 0
        for i in range(num_files):
            output_file = os.path.join(output_folder, f'output_{i + 1}.txt')
            
            left_portion = left_image_paths[current_path_index:current_path_index + paths_per_file]
            right_portion = right_image_paths[current_path_index:current_path_index + paths_per_file]
    
            # 合并在file中,左图在偶数行,右图在奇数行
            portion = []
            for left_path, right_path in zip(left_portion, right_portion):
                portion.append(left_path)   # 左图路径
                portion.append(right_path)  # 右图路径
    
            # 填充空行至偶数行
            while len(portion) < (paths_per_file * 2):
                portion.append('')  # 填充空行
    
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
    
            current_path_index += paths_per_file
            if current_path_index >= len(left_image_paths) or current_path_index >= len(right_image_paths):
                break  # 如果任何一种路径用尽,则停止处理
    
        print(f"成功将图像路径均分成 {num_files} 份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
        num_files = 10  # 指定要保存的文件数量
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files)
    

    代码解释:

    1. 路径合并: 使用 zip_longest 合并左右图像路径,确保同一索引下的左图和右图配对。

    2. 计算基本路径数: 每个文件的总路径数计算为 paths_per_file。确保总路径数被 num_files 平均分配,并调整为偶数。

    3. 平衡左图和右图数量: 为了确保每个文件中左右图数量平衡,我们将 paths_per_file 除以 2,来确定每个文件中的左图和右图的数量。

    4. 随机填充空行: 如果路径数不足以填充文件的偶数行,则填入空行。

    通过这样的实现,每个输出文件将准确合并左右图像路径,并确保输出的行数是偶数且合理分布。

  13. User

    不填充空行至偶数行,而是遇到文件是奇数行则顺延写入下一行

  14. Assistant

    为了满足你的需求,我们将按照以下步骤进行修改:

    1. 不填充空行: 如果文件路径数量为奇数,我们将在写入时将其合并到下一个文件中。换句话说,当当前文件的写入量为奇数时,我们将将最后一行的右图路径推迟到下一个文件。

    2. 均匀分配左右图路径: 确保每个输出文件尽量包含相同数量的左图和右图路径。

    以下是更新后的代码实现:

    import os
    import glob
    from itertools import zip_longest
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files):
        os.makedirs(output_folder, exist_ok=True)
    
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
    
        total_left = len(left_image_paths)
        total_right = len(right_image_paths)
    
        total_paths = min(total_left, total_right) * 2  # 每对左右图像一共占用2行
    
        # 每个文件应该包含的路径数量
        paths_per_file = total_paths // num_files
    
        # 确保路径数是偶数
        if paths_per_file % 2 != 0:
            paths_per_file -= 1
    
        # 如果计算出的路径数为0,则调整为至少2行
        if paths_per_file <= 0:
            paths_per_file = 2
    
        # 每个文件中要写入的左图和右图数量
        left_paths_per_file = paths_per_file // 2
    
        current_left_index = 0
        current_right_index = 0
    
        for i in range(num_files):
            output_file = os.path.join(output_folder, f'output_{i + 1}.txt')
            portion = []
    
            # 从左图和右图列表中提取路径
            for _ in range(left_paths_per_file):
                if current_left_index < total_left:
                    portion.append(left_image_paths[current_left_index])
                    current_left_index += 1
            
            for _ in range(left_paths_per_file):
                if current_right_index < total_right:
                    portion.append(right_image_paths[current_right_index])
                    current_right_index += 1
    
            # 如果最终的集合为奇数,则将最后一个右图推迟到下一个文件
            if len(portion) % 2 != 0 and current_right_index < total_right:
                next_right_path = right_image_paths[current_right_index]
                current_right_index += 1
                portion.append(next_right_path)  # 下一右图路径推迟
    
            # 写入文件
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
    
            # 检查是否用尽所有路径
            if current_left_index >= total_left and current_right_index >= total_right:
                break
    
        print(f"成功将图像路径均分成 {num_files} 份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'
        left_extension = '_left.png'
        right_extension = '_right.png'
        output_folder = './'
        num_files = 10  # 指定要保存的文件数量
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files)
    

    主要修改点:

    1. 不填充空行: 当遇到文件的最后一行为奇数时,保持这个奇数行到下一个文件中。

    2. 路径的合理顺序: 在提取路径时,保持路径的顺序从左图和右图分别提取,并控制它们的数量。

    3. 处理文件写入: 在写入文件前检查路径的数量,如果为奇数则将右图推迟写入下一个文件。

    通过这种方式,我们可以确保每个输出文件的内容是合理的,并且满足左图和右图路径交替的要求。

  15. User

    你理解错了,是:如果文件路径数量为奇数,我们将在写入时将其合并到下一个文件中。换句话说,当当前文件的写入量为奇数时,我们将将最后一行的路径推迟到下一个文件。

  16. Assistant

    感谢你的澄清!根据你的意思,如果在写入某个文本文件时,已经写入的文件路径数量为奇数,则最后一个路径将会被推迟到下一个文件中。这会确保任何文件中的路径数量始终为偶数。

    以下是符合你需求的更新代码:

    import os
    import glob
    
    def split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files):
        # 确保输出文件夹存在
        os.makedirs(output_folder, exist_ok=True)
    
        # 获取指定后缀的所有图像文件路径
        left_image_paths = glob.glob(os.path.join(input_folder, f'*{left_extension}'))
        right_image_paths = glob.glob(os.path.join(input_folder, f'*{right_extension}'))
    
        total_left = len(left_image_paths)
        total_right = len(right_image_paths)
    
        # 计算可以使用的路径对
        total_pairs = min(total_left, total_right)
        total_paths = total_pairs * 2  # 每对路径都有左右图
    
        # 每个文件应该包含的路径数量,这里加倍以处理配对
        paths_per_file = total_paths // num_files
    
        # 确保路径数是偶数
        if paths_per_file % 2 != 0:
            paths_per_file -= 1
    
        # 如果路径总数无法均分,则减少文件数量并相应调整路径数
        if paths_per_file <= 0:
            paths_per_file = 2  # 至少确保每个文件能写入两个路径
    
        # 计算每个文件要写入的左图和右图数量
        left_paths_per_file = paths_per_file // 2
    
        current_left_index = 0
        current_right_index = 0
        last_right_path = None  # 用于存储上一个右图路径以便于顺延到下一个文件
    
        for i in range(num_files):
            output_file = os.path.join(output_folder, f'output_{i + 1}.txt')
            portion = []
    
            # 从左图中提取路径
            for _ in range(left_paths_per_file):
                if current_left_index < total_left:
                    portion.append(left_image_paths[current_left_index])
                    current_left_index += 1
    
            # 从右图中提取路径
            for _ in range(left_paths_per_file):
                if current_right_index < total_right:
                    portion.append(right_image_paths[current_right_index])
                    current_right_index += 1
    
            # 检查当前文件的路径数量
            if len(portion) % 2 != 0:  # 如果当前数量为奇数
                if current_right_index < total_right:
                    # 将最后的右图路径推迟
                    last_right_path = right_image_paths[current_right_index]
                    current_right_index += 1
                    portion.pop()  # 移除最后一个右图路径
    
            # 写入文件
            with open(output_file, 'w') as f:
                for path in portion:
                    f.write(path + '\n')
    
            # 如果设置了推迟的路径,写入下一个文件
            if last_right_path is not None:
                with open(output_file, 'a') as f:
                    f.write(last_right_path + '\n')
                last_right_path = None  # 重置推迟路径
    
            # 检查是否用尽所有路径
            if current_left_index >= total_left and current_right_index >= total_right:
                break
    
        print(f"成功将图像路径均分成 {num_files} 份并写入到 '{output_folder}' 文件夹中。")
    
    if __name__ == '__main__':
        # 输入参数
        input_folder = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono'  # 替换为你的图像文件夹路径
        left_extension = '_left.png'  # 左图后缀
        right_extension = '_right.png' # 右图后缀
        output_folder = './'  # 替换为你想保存输出文件的文件夹路径
        num_files = 10  # 指定要保存的文件数量
    
        split_image_paths_to_txt(input_folder, left_extension, right_extension, output_folder, num_files)
    

    主要修改点:

    1. 检查当前写入路径的数量: 在合并路径到 portion 列表后,检查路径数量是否为奇数。

    2. 推迟路径的处理: 用 last_right_path 存储最后一个右图路径,若当前文件的路径数量为奇数,推迟该路径到下一个文件中。

    3. 写入文件: 当前文件路径写完后,在检查并写入推迟的路径。

    通过这种方法,您可以确保每个输出文件的路径数始终为偶数,从而满足您的需求。

  17. User

    import argparse import os,glob,sys,yaml,cv2 import time,datetime import numpy as np import torch import torch.nn as nn import torch.nn.parallel import torch.backends.cudnn as cudnn import torch.optim as optim import torch.nn.functional as F import torch.utils.data from thop import profile INVALID_DISPARITY_F32 = 0.-300. INVALID_DISPARITY_U16 = 32768

    from util import save_checkpoint,AverageMeter,save_float_to_colormap,normerWrong,normer,normerImageNet,resizer,constantNorm

    from lightStereo.lightstereo_refine import LightStereo

    from lightStereo.lightstereo import LightStereo

    def dispFloatToUint16(dispFOrig, ratio=1.): ''' disparity range from -300 to -0 is currently not suppoted for read/write to png file ''' dispF = dispFOrig.copy()ratio dispInvMsk=(dispF<=INVALID_DISPARITY_F32ratio) dispValMsk=(dispF>INVALID_DISPARITY_F32*ratio) dispF[dispValMsk] *= 128. dispF[dispInvMsk] = INVALID_DISPARITY_U16 dispU16 = dispF.astype(np.uint16) return dispU16

    def convert_relu_to_relu6(model): for child_name, child in model.named_children(): if isinstance(child, (nn.ReLU, nn.LeakyReLU)): #print(child_name) setattr(model, child_name, nn.ReLU6(inplace=True)) else: convert_relu_to_relu6(child)

    gaussian blur

    def gaussBlurCore(img, ksize=(3,3), sigma=0.35): kw = int(ksize[0]) kh = int(ksize[1]) blurImg = cv2.GaussianBlur(img, (kw,kh), sigma) return blurImg

    def gaussBlur(left, right): left, right = left.copy(), right.copy() left, right = left, right

    left     = gaussBlurCore(left)
    left,right   = left, right
    return left, right
    

    def colorTransfer(Isrc, Iref): Is = Isrc.copy() Ir = Iref.copy() #plt.imshow(Ir[...,::-1])
    #plt.show() #plt.imshow(Is[...,::-1]) #plt.show() #BGR->LAB valid = ((Iref[:,:,0]>0) & (Iref[:,:,1]>0) & (Iref[:,:,2]>0)) LabIs = cv2.cvtColor(Is,cv2.COLOR_BGR2LAB) LabIr = cv2.cvtColor(Ir,cv2.COLOR_BGR2LAB) #mean、std Is_means = [0, 0, 0] Ir_means = [0, 0, 0] Is_stdevs = [0, 0, 0] Ir_stdevs = [0, 0, 0] LabIs = LabIs.astype(np.float32)/255. LabIr = LabIr.astype(np.float32)/255. for i in range(3): Is_means[i] += LabIs[:,:,i].mean() Ir_means[i] += LabIr[:,:,i][valid].mean() Is_stdevs[i] += (LabIs[:,:,i].std() + 1e-9) Ir_stdevs[i] += (LabIr[:,:,i][valid].std() + 1e-9) thresh = [a/b for a,b in zip(Ir_stdevs,Is_stdevs)] LabIt = thresh*(LabIs -Is_means) + Ir_means

    # [0-255]
    LabIt = (LabIt*255.)
    LabIt *= (LabIt>0)
    LabIt = (LabIt * (LabIt<=255) + 255 * (LabIt>255)).astype(np.uint8)
    
    #show
    It = cv2.cvtColor(LabIt,cv2.COLOR_LAB2BGR)
    #plt.imshow(It)
    #plt.show()
    
    return It
    

    def getYamlCfg(fn='models/configModelTest.yaml'): f = open(fn, 'r', encoding='utf-8') cfg = f.read() content = yaml.load(cfg, Loader=yaml.FullLoader) return content

    def initModels(content, modelFolder='models', args=None): numOfModels = len(list(content.keys())) #importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        importedFolder = __import__(content[modelName]['modelFolder'])
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'], args=args)
        break
    
    return singleModel['classInst']
    

    def initModelsBug(content, modelFolder='models'): numOfModels = len(list(content.keys())) importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'])
        break
    
    return singleModel['classInst']
    

    def loadPretrain(model, pretrained, strict=False): oldCkpt = torch.load(pretrained) if pretrained.find('.tar')>=0: oldCkpt = oldCkpt['state_dict'] newCkpt = {} for k in oldCkpt.keys(): newCkpt[k.replace('module.','')] = oldCkpt[k] model.load_state_dict(newCkpt, strict=strict) return model

    Training settings

    parser = argparse.ArgumentParser(description='Stereo training...') parser.add_argument('--data_parent_path', type=str, default='/home/notebook/data/group/xizhong_xxz/', help="location to save models") parser.add_argument('--data_config_path', type=str, default='./configs/configDatasetMultiscale.yaml', help="location to save models") parser.add_argument('--model_config_path', type=str, default='./configs/configModel.yaml', help="location to save models") parser.add_argument('--loss_config_path', type=str, default='./configs/configLoss.yaml', help="location to save models") parser.add_argument('--save_path', type=str, default='./rectify', help="location to save models") parser.add_argument('--use_gru_refine', type=int, default=0, help="if use gru refine for disp output") parser.add_argument('--useBackboneV2', type=int, default=0, help='1 use mobilenet') parser.add_argument('--att_relu6', type=int, default=0, help='1 use relu6 for att module') parser.add_argument('--convex_up', type=int, default=0, help='1 use convex upsample') parser.add_argument('--transAtt', type=int, default=0, help='1 use self att') parser.add_argument('--agg_blocks', default=[8,16,32], metavar='N', nargs='*', help='set the block number for each stage') parser.add_argument('--pretrained_Backbone', type=int, default=1, help='1 use pretrained backbone to extractor feature') parser.add_argument('--sample_tail', type=int, default=0, help="if add a tail refinement for output quantize") parser.add_argument('--use_mono', type=int, default=0, help="if use mono optimize stereo")

    parser.add_argument('--useResNet', type=int, default=0, help='use resnet as backbone') parser.add_argument('--validateOnly', type=int, default=0, help='do validation only. Default=0') parser.add_argument('--warmup', type=int, default=0, help='do warmup training or not, Default=0') parser.add_argument('--abnormAug', type=int, default=0, help='do abnormal augmenation such as thin plate transform or diagonal epipolar transform') parser.add_argument('--eraseAug', type=int, default=0, help='do erasing augmenation') parser.add_argument('--occAug', type=int, default=0, help='do occlusion augmentation in right image branch') parser.add_argument('--defocusAug', type=int, default=0, help='do blur augmentation in all image branches') parser.add_argument('--gradLoss', type=int, default=0, help='use gradient loss for supervision') parser.add_argument('--normLoss', type=int, default=0, help='use normal loss for supervision') parser.add_argument('--smtLoss', type=int, default=0, help='use smoothness loss for self-supervision') parser.add_argument('--use_dn', type=int, default=0, help='0 for bn, 1 for dn') parser.add_argument('--mobile', type=int, default=0, help='0 for bn, 1 for mobile') parser.add_argument('--use_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--use_refine_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--backbone_relu6_only', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--noNormInput', type=int, default=0, help='normalize input to 0.0 ~ 1.0') parser.add_argument('--rgbOrder', type=int, default=0, help='0 for bgr, 1 for rgb') parser.add_argument('--normGT', type=int, default=0, help='normalize GT to 0.0 ~ 1.0') parser.add_argument('--ada_sigma', type=int, default=0, help='0 for fixed sigma, 1 for adaptive sigma') parser.add_argument('--depth_wise', type=int, default=0, help='depth wise conv for decoder') parser.add_argument('--ada_cost', type=int, default=1, help='0 for fixed cost, 1 for adaptive cost') parser.add_argument('--simple_refine', type=int, default=0, help='1 for simple refiner, 0 for warp refiner') parser.add_argument('--rightDown2x', type=int, default=0, help='1 for right image plane down 2x, 0 for no downscale') parser.add_argument('--clipGrad', type=int, default=0, help='use gradient clipping for training') parser.add_argument('--clip', type=float, default=2.1, help='clipping range') parser.add_argument('--skyFill', type=int, default=1, help='fill sky area with disparity 0.0 with semantic label') parser.add_argument('--use_refine', type=int, default=0, help='use refinement blocks') parser.add_argument('--refine_stages', type=int, default=2, help='use refinement blocks') parser.add_argument('--warp_feature', type=int, default=0, help='warp feature or original image') parser.add_argument('--wRec', type=float, default=0.0, help='gradient loss weight') parser.add_argument('--proj_ch', type=int, default=3, help='channels to reconsrtuct') parser.add_argument('--pre_scale', type=float, default=0.666667, help='pre-scale') parser.add_argument('--cat2Fuse', type=int, default=0, help='costs cat to fuse') parser.add_argument('--trainSceneFlowOnly', type=int, default=0, help='train scene flow dataset only') parser.add_argument('--wGrad', type=float, default=0.5, help='gradient loss weight') parser.add_argument('--wSmt', type=float, default=0.5, help='smooth loss weight') parser.add_argument('--inconsistAug', type=int, default=0, help='inconsistancy augmentation for LR pairs') parser.add_argument('--imageNetInputNorm', type=int, default=0, help='inputs normalized like in imagenet') parser.add_argument('--constantNorm', type=int, default=0, help='inputs normalized to [-1, 1]') parser.add_argument('--useTransformer', type=int, default=0, help='use transformer blocks') parser.add_argument('--correctCorr', type=int, default=0, help='use correct correlation') parser.add_argument('--copyPaste', type=int, default=1, help='use copy paste tech.') parser.add_argument('--zeroBlack', type=int, default=0, help='black area filled with zero when normalizing.') parser.add_argument('--zeroInvalidGt', type=int, default=0, help='black area filled with zero gt.')

    parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range") #parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range")

    parser.add_argument('--shift', type=int, default=0, help='random shift of left image. Default=0') #shift value must be zero for cost volume aggregation (soft argmin) based network parser.add_argument('--crop_height', type=int, default=640, help="crop height") parser.add_argument('--crop_width', type=int, default=768, help="crop width") parser.add_argument('--resume', type=str, default='', help="resume from saved model") parser.add_argument('--start_epoch', type=int, default=0, help='the epoch to resume training') parser.add_argument('--pretrained', dest='pretrained', default=None, help='path to pre-trained model')

    parser.add_argument('--batch_size', type=int, default=8, help='training batch size') parser.add_argument('--val_batch_size', type=int, default=8, help='testing batch size') parser.add_argument('--workers', type=int, default=32, help='number of threads') parser.add_argument('--nEpochs', type=int, default=64, help='number of epochs to train for') parser.add_argument('--solver', default='adam',choices=['adam','sgd'], help='solver algorithms') parser.add_argument('--lr', type=float, default=0.0008, help='Learning Rate. Default=0.001') parser.add_argument('--lr_decay', type=float, default=0.5, help='Learning Rate descending rete. Default=0.5')

    ''' Attention: milestones should be ignored(keep unchanged), since it's adapted to nEpochs in the latter main function ''' #####parser.add_argument('--milestones', default=[14,28,42,56], metavar='N', nargs='', help='epochs at which learning rate is divided by 2')
    parser.add_argument('--milestones', default=[10,20,30,40,50,60], metavar='N', nargs='
    ', help='epochs at which learning rate is divided by 2') #parser.add_argument('--milestones', default=[13,23,33,43,53,63], metavar='N', nargs='*', help='epochs at which learning rate is divided by 2')

    #parser.add_argument('--weight_decay', '--wd', default=4e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--weight_decay', '--wd', default=1e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--bias_decay', default=0, type=float, metavar='B', help='bias decay') parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum for sgd, alpha parameter for adam') parser.add_argument('--beta', default=0.999, type=float, metavar='M', help='beta parameter for adam')

    ''' ascending order means use loss.sum()/batchSize, which is map level average descending order means use loss.mean(), which is pixel level average ''' #parser.add_argument('--multiscale_weights', '-w', default=[0.005,0.01,0.02,0.08,0.32], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) #parser.add_argument('--multiscale_weights', '-w', default=[0.32,0.08,0.02,0.01,0.005], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) parser.add_argument('--multiscale_weights', '-w', default=[1./3, 2./3, 1., 1., 1.], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6'))

    parser.add_argument('--seed', type=int, default=2022, help='random seed to use. Default=123')

    parser.add_argument('--print_freq', '-p', default=50, type=int, metavar='N', help='print frequency') parser.add_argument('--save_freq', '-s', default=5, type=int, metavar='N', help='save checkpoint frequency') device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    def main():

    args = parser.parse_args()
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
    print('=> get test data pairs')
    # args.data_path="/home/notebook/data/group/liulibo/stereoProject/rectify/bars/"
    # args.data_path="/home/notebook/data/group/liulibo/MiDaS/langan_refine_data/"
    args.data_path="/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/"
    
    args.flip_LR=0
    args.useMinMax=0
    lists  =[args.data_path+file  for file in os.listdir(args.data_path)  if(("left"  in file  or "master"  in file)  and "disp"  not in file)]
    total  = len(lists)
    print(total)
    #pause
    
    print('=> get models from configuration file')
    content = getYamlCfg(fn='configs/configModelTest.yaml')
    model = LightStereo(parser)
    model = model.to(device).eval()
    # model   = loadPretrain(model, "./checkpoint/refiner_finetune_20240918/model_best.pth.tar", strict=False)
    model   = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
    print('=> infer')
    count=0
    # for idx in range(total):
    for file in os.listdir(args.data_path):  
        if(("left"  in file  or "master"  in file)):
            if "Disp"   in file:
                continue
            try:
                srcLFn    = args.data_path+file
                srcRFn    = srcLFn.replace('left','right').replace('master', 'slave')
                print(srcLFn)
                print(srcRFn)
                lImg      = cv2.imread(srcLFn,1)
                rImg      = cv2.imread(srcRFn,1)
                h,w,c=lImg.shape
                hh,ww,cc=rImg.shape
                lMask     = ((lImg[:,:,0]==0) & (lImg[:,:,1]==0) & (lImg[:,:,2]==0)).astype(np.uint8)
            except:
                continue
            if args.flip_LR>0:
                lImg  = lImg[:,::-1,:]
                rImg  = rImg[:,::-1,:]
                lMask = lMask[:,::-1]
    
            rszH,rszW = lImg.shape[0],lImg.shape[1]
            lImg,rImg = resizer(lImg,rImg,args)
    
            # if args.rgbOrder > 0:
            #     lImg= lImg[:,:,::-1].copy()
            #     rImg= rImg[:,:,::-1].copy()
            # if args.imageNetInputNorm <= 0:
            #     imgPair   = normer(lImg, rImg)
            # else:
            #     if args.constantNorm:
            #         imgPair   = constantNorm(lImg, rImg)
            #     else:
            imgPair   = normerImageNet(lImg, rImg)
            
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():        
                output= model(imgPairTs)
    
            if isinstance(output, list):
                output    = output[-1].squeeze().cpu().numpy()
            else:
                output    = output.squeeze().cpu().numpy()
            if args.flip_LR>0:
                output    = output[:,::-1]
                lMask     = lMask[:,::-1]
    
            outH,outW = output.shape[0],output.shape[1]
            scaleDisp = rszW * 1. / outW
    
            output    = cv2.resize(output, (rszW,rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
            #print(output.min())
    
            # dispU16   = dispFloatToUint16(output, ratio=3)
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
            cv2.imwrite(output_path +'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
    
            # print(args.save_path)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp_gray').replace('master','gru_leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp').replace('master','gru_leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp_gray').replace('master','leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp').replace('master','leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
        
    

    if name == 'main': main()

    对于这个代码,在不改变代码功能和结构的前提下,把数据接口改成读取txt,txt的偶数行是左图路径,奇数行是右图路径

  18. Assistant

    要将数据接口修改为从一个文本文件中读取图像路径,其中偶数行是左图的路径,奇数行是右图的路径,同时保持代码的整体功能和结构,您可以进行以下修改:

    1. 读取文件内容: 使用 Python 文件操作读取路径。
    2. 提取路径: 在处理图像之前,需要根据行号来区分左图和右图路径。

    以下是修改后的 main() 函数的代码示例,确保从指定的 txt 文件中读取路径:

    def main():
        args = parser.parse_args()
    
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        print('=> get test data pairs')
    
        # 路径改为txt文件
        args.data_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/image_paths.txt'  # 替换为你的文本文件路径
    
        # 从文本文件读取路径
        with open(args.data_path, 'r') as f:
            lists = [line.strip() for line in f.readlines()]
    
        total = len(lists)
        print(f'Total image pairs: {total // 2}')  # 计算图像对数量(假设每一对左图和右图各占一行)
    
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        count = 0
        
        for i in range(0, total, 2):  # 每次读取两行
            srcLFn = lists[i]  # 偶数行是左图
            srcRFn = lists[i + 1]  # 奇数行是右图
    
            print(srcLFn)
            print(srcRFn)
            
            # 读取左图和右图
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
    
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} or {srcRFn}')
                continue
            
            h,w,c = lImg.shape
            hh,ww,cc = rImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
    
            if args.flip_LR > 0:
                lImg = lImg[:, ::-1, :]
                rImg = rImg[:, ::-1, :]
                lMask = lMask[:, ::-1]
    
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
            
            imgPair = normerImageNet(lImg, rImg)
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
                
            if args.flip_LR > 0:
                output = output[:, ::-1]
                lMask = lMask[:, ::-1]
    
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
    
            # 保存结果
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    
    if __name__ == '__main__':
        main()
    

    主要修改点:

    1. 读取图像路径: 使用 with open() 读取指定的文本文件,并存储每一行到 lists 列表中。

    2. 选择路径: 在 for 循环中遍历 lists,每次迭代读取偶数行作为左图路径,奇数行作为右图路径。

    3. 路径检查: 加入了对图像读取错误的检查,以避免程序在读取 文件失败时崩溃。

    4. 输出路径: 在保存输出结果时,与原来的结构保持一致。

    以上修改确保了代码的功能未变,只是数据输入的方式发生了变化,现在从文本文件中读取左图和右图路径。您可以根据需求调整 args.data_path 的设置,以指向您的文本文件。

  19. User

    Traceback (most recent call last): File "test_repair.py", line 336, in main() File "test_repair.py", line 304, in main if args.flip_LR > 0: AttributeError: 'Namespace' object has no attribute 'flip_LR'

  20. Assistant

    AttributeError: 'Namespace' object has no attribute 'flip_LR' 这个错误表示 args 对象中没有 flip_LR 这个属性。这通常是因为在命令行解析参数时没有指定 flip_LR 这个参数。

    要解决这个问题,您可以在参数解析器中添加 flip_LR 参数。以下是如何在代码中添加此参数的示例:

    1. 在解析参数部分添加 flip_LR 参数的定义,确保 flip_LR 参数能够被正确解析。

    将以下代码添加到参数解析部分:

    parser.add_argument('--flip_LR', type=int, default=0, help='1 to flip left-right images, 0 to do nothing')
    

    完整的参数解析部分看起来应该类似于以下内容:

    # Training settings
    parser = argparse.ArgumentParser(description='Stereo training...')
    parser.add_argument('--data_parent_path', type=str, default='/home/notebook/data/group/xizhong_xxz/', help="location to save models")
    # ... 其他参数 ...
    parser.add_argument('--flip_LR', type=int, default=0, help='1 to flip left-right images, 0 to do nothing')
    # ... 其他参数 ...
    

    完整修改后的 main() 函数代码如下:

    def main():
        args = parser.parse_args()
    
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        print('=> get test data pairs')
    
        # 路径改为 txt 文件
        args.data_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/image_paths.txt'  # 替换为你的文本文件路径
    
        # 从文本文件读取路径
        with open(args.data_path, 'r') as f:
            lists = [line.strip() for line in f.readlines()]
    
        total = len(lists)
        print(f'Total image pairs: {total // 2}')  # 计算图像对数量(假设每一对左图和右图各占一行)
    
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        count = 0
        
        for i in range(0, total, 2):  # 每次读取两行
            srcLFn = lists[i]  # 偶数行是左图
            srcRFn = lists[i + 1]  # 奇数行是右图
    
            print(srcLFn)
            print(srcRFn)
            
            # 读取左图和右图
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
    
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} or {srcRFn}')
                continue
            
            h,w,c = lImg.shape
            hh,ww,cc = rImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
    
            if args.flip_LR > 0:
                lImg = lImg[:, ::-1, :]
                rImg = rImg[:, ::-1, :]
                lMask = lMask[:, ::-1]
    
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
            
            imgPair = normerImageNet(lImg, rImg)
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
                
            if args.flip_LR > 0:
                output = output[:, ::-1]
                lMask = lMask[:, ::-1]
    
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
    
            # 保存结果
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    

    总结

    确保在参数解析器中添加 --flip_LR 参数,并在脚本运行时指定该参数以避免 AttributeError。如果在命令行中运行该脚本,则可以通过添加 --flip_LR 1 或 --flip_LR 0 来控制图像是否翻转。如果您直接运行该脚本并没有提供命令行参数,正常情况下代码将默认使用 flip_LR=0。

  21. User

    import argparse import os,glob,sys,yaml,cv2 import time,datetime import numpy as np import torch import torch.nn as nn import torch.nn.parallel import torch.backends.cudnn as cudnn import torch.optim as optim import torch.nn.functional as F import torch.utils.data from thop import profile INVALID_DISPARITY_F32 = 0.-300. INVALID_DISPARITY_U16 = 32768

    from util import save_checkpoint,AverageMeter,save_float_to_colormap,normerWrong,normer,normerImageNet,resizer,constantNorm

    from lightStereo.lightstereo_refine import LightStereo

    from lightStereo.lightstereo import LightStereo

    def dispFloatToUint16(dispFOrig, ratio=1.): ''' disparity range from -300 to -0 is currently not suppoted for read/write to png file ''' dispF = dispFOrig.copy()ratio dispInvMsk=(dispF<=INVALID_DISPARITY_F32ratio) dispValMsk=(dispF>INVALID_DISPARITY_F32*ratio) dispF[dispValMsk] *= 128. dispF[dispInvMsk] = INVALID_DISPARITY_U16 dispU16 = dispF.astype(np.uint16) return dispU16

    def convert_relu_to_relu6(model): for child_name, child in model.named_children(): if isinstance(child, (nn.ReLU, nn.LeakyReLU)): #print(child_name) setattr(model, child_name, nn.ReLU6(inplace=True)) else: convert_relu_to_relu6(child)

    gaussian blur

    def gaussBlurCore(img, ksize=(3,3), sigma=0.35): kw = int(ksize[0]) kh = int(ksize[1]) blurImg = cv2.GaussianBlur(img, (kw,kh), sigma) return blurImg

    def gaussBlur(left, right): left, right = left.copy(), right.copy() left, right = left, right

    left     = gaussBlurCore(left)
    left,right   = left, right
    return left, right
    

    def colorTransfer(Isrc, Iref): Is = Isrc.copy() Ir = Iref.copy() #plt.imshow(Ir[...,::-1])
    #plt.show() #plt.imshow(Is[...,::-1]) #plt.show() #BGR->LAB valid = ((Iref[:,:,0]>0) & (Iref[:,:,1]>0) & (Iref[:,:,2]>0)) LabIs = cv2.cvtColor(Is,cv2.COLOR_BGR2LAB) LabIr = cv2.cvtColor(Ir,cv2.COLOR_BGR2LAB) #mean、std Is_means = [0, 0, 0] Ir_means = [0, 0, 0] Is_stdevs = [0, 0, 0] Ir_stdevs = [0, 0, 0] LabIs = LabIs.astype(np.float32)/255. LabIr = LabIr.astype(np.float32)/255. for i in range(3): Is_means[i] += LabIs[:,:,i].mean() Ir_means[i] += LabIr[:,:,i][valid].mean() Is_stdevs[i] += (LabIs[:,:,i].std() + 1e-9) Ir_stdevs[i] += (LabIr[:,:,i][valid].std() + 1e-9) thresh = [a/b for a,b in zip(Ir_stdevs,Is_stdevs)] LabIt = thresh*(LabIs -Is_means) + Ir_means

    # [0-255]
    LabIt = (LabIt*255.)
    LabIt *= (LabIt>0)
    LabIt = (LabIt * (LabIt<=255) + 255 * (LabIt>255)).astype(np.uint8)
    
    #show
    It = cv2.cvtColor(LabIt,cv2.COLOR_LAB2BGR)
    #plt.imshow(It)
    #plt.show()
    
    return It
    

    def getYamlCfg(fn='models/configModelTest.yaml'): f = open(fn, 'r', encoding='utf-8') cfg = f.read() content = yaml.load(cfg, Loader=yaml.FullLoader) return content

    def initModels(content, modelFolder='models', args=None): numOfModels = len(list(content.keys())) #importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        importedFolder = __import__(content[modelName]['modelFolder'])
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'], args=args)
        break
    
    return singleModel['classInst']
    

    def initModelsBug(content, modelFolder='models'): numOfModels = len(list(content.keys())) importedFolder= import(modelFolder)

    singleModel  = {}
    for idx in range(numOfModels):
        modelName    = list(content.keys())[idx]
        if content[modelName]['used4Train'] is not True:
            continue
    
        print('=> Importing model-{}'.format(modelName))
        moduleImported = getattr(importedFolder, content[modelName]['moduleName'])
        classImported  = getattr(moduleImported, content[modelName]['className'])
    
        singleModel['classInst']   = classImported(batchNorm=content[modelName]['batchNorm'], pred_disp=content[modelName]['pred_disp'])
        break
    
    return singleModel['classInst']
    

    def loadPretrain(model, pretrained, strict=False): oldCkpt = torch.load(pretrained) if pretrained.find('.tar')>=0: oldCkpt = oldCkpt['state_dict'] newCkpt = {} for k in oldCkpt.keys(): newCkpt[k.replace('module.','')] = oldCkpt[k] model.load_state_dict(newCkpt, strict=strict) return model

    Training settings

    parser = argparse.ArgumentParser(description='Stereo training...') parser.add_argument('--data_parent_path', type=str, default='/home/notebook/data/group/xizhong_xxz/', help="location to save models") parser.add_argument('--data_config_path', type=str, default='./configs/configDatasetMultiscale.yaml', help="location to save models") parser.add_argument('--model_config_path', type=str, default='./configs/configModel.yaml', help="location to save models") parser.add_argument('--loss_config_path', type=str, default='./configs/configLoss.yaml', help="location to save models") parser.add_argument('--save_path', type=str, default='./rectify', help="location to save models") parser.add_argument('--use_gru_refine', type=int, default=0, help="if use gru refine for disp output") parser.add_argument('--useBackboneV2', type=int, default=0, help='1 use mobilenet') parser.add_argument('--att_relu6', type=int, default=0, help='1 use relu6 for att module') parser.add_argument('--convex_up', type=int, default=0, help='1 use convex upsample') parser.add_argument('--transAtt', type=int, default=0, help='1 use self att') parser.add_argument('--agg_blocks', default=[8,16,32], metavar='N', nargs='*', help='set the block number for each stage') parser.add_argument('--pretrained_Backbone', type=int, default=1, help='1 use pretrained backbone to extractor feature') parser.add_argument('--sample_tail', type=int, default=0, help="if add a tail refinement for output quantize") parser.add_argument('--use_mono', type=int, default=0, help="if use mono optimize stereo")

    parser.add_argument('--useResNet', type=int, default=0, help='use resnet as backbone') parser.add_argument('--validateOnly', type=int, default=0, help='do validation only. Default=0') parser.add_argument('--warmup', type=int, default=0, help='do warmup training or not, Default=0') parser.add_argument('--abnormAug', type=int, default=0, help='do abnormal augmenation such as thin plate transform or diagonal epipolar transform') parser.add_argument('--eraseAug', type=int, default=0, help='do erasing augmenation') parser.add_argument('--occAug', type=int, default=0, help='do occlusion augmentation in right image branch') parser.add_argument('--defocusAug', type=int, default=0, help='do blur augmentation in all image branches') parser.add_argument('--gradLoss', type=int, default=0, help='use gradient loss for supervision') parser.add_argument('--normLoss', type=int, default=0, help='use normal loss for supervision') parser.add_argument('--smtLoss', type=int, default=0, help='use smoothness loss for self-supervision') parser.add_argument('--use_dn', type=int, default=0, help='0 for bn, 1 for dn') parser.add_argument('--mobile', type=int, default=0, help='0 for bn, 1 for mobile') parser.add_argument('--use_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--use_refine_relu6', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--backbone_relu6_only', type=int, default=0, help='0 for relu, 1 for relu6') parser.add_argument('--noNormInput', type=int, default=0, help='normalize input to 0.0 ~ 1.0') parser.add_argument('--rgbOrder', type=int, default=0, help='0 for bgr, 1 for rgb') parser.add_argument('--normGT', type=int, default=0, help='normalize GT to 0.0 ~ 1.0') parser.add_argument('--ada_sigma', type=int, default=0, help='0 for fixed sigma, 1 for adaptive sigma') parser.add_argument('--depth_wise', type=int, default=0, help='depth wise conv for decoder') parser.add_argument('--ada_cost', type=int, default=1, help='0 for fixed cost, 1 for adaptive cost') parser.add_argument('--simple_refine', type=int, default=0, help='1 for simple refiner, 0 for warp refiner') parser.add_argument('--rightDown2x', type=int, default=0, help='1 for right image plane down 2x, 0 for no downscale') parser.add_argument('--clipGrad', type=int, default=0, help='use gradient clipping for training') parser.add_argument('--clip', type=float, default=2.1, help='clipping range') parser.add_argument('--skyFill', type=int, default=1, help='fill sky area with disparity 0.0 with semantic label') parser.add_argument('--use_refine', type=int, default=0, help='use refinement blocks') parser.add_argument('--refine_stages', type=int, default=2, help='use refinement blocks') parser.add_argument('--warp_feature', type=int, default=0, help='warp feature or original image') parser.add_argument('--wRec', type=float, default=0.0, help='gradient loss weight') parser.add_argument('--proj_ch', type=int, default=3, help='channels to reconsrtuct') parser.add_argument('--pre_scale', type=float, default=0.666667, help='pre-scale') parser.add_argument('--cat2Fuse', type=int, default=0, help='costs cat to fuse') parser.add_argument('--trainSceneFlowOnly', type=int, default=0, help='train scene flow dataset only') parser.add_argument('--wGrad', type=float, default=0.5, help='gradient loss weight') parser.add_argument('--wSmt', type=float, default=0.5, help='smooth loss weight') parser.add_argument('--inconsistAug', type=int, default=0, help='inconsistancy augmentation for LR pairs') parser.add_argument('--imageNetInputNorm', type=int, default=0, help='inputs normalized like in imagenet') parser.add_argument('--constantNorm', type=int, default=0, help='inputs normalized to [-1, 1]') parser.add_argument('--useTransformer', type=int, default=0, help='use transformer blocks') parser.add_argument('--correctCorr', type=int, default=0, help='use correct correlation') parser.add_argument('--copyPaste', type=int, default=1, help='use copy paste tech.') parser.add_argument('--zeroBlack', type=int, default=0, help='black area filled with zero when normalizing.') parser.add_argument('--zeroInvalidGt', type=int, default=0, help='black area filled with zero gt.')

    parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range") #parser.add_argument('--maxdisp', type=int, default=120, help="max disparity range")

    parser.add_argument('--shift', type=int, default=0, help='random shift of left image. Default=0') #shift value must be zero for cost volume aggregation (soft argmin) based network parser.add_argument('--crop_height', type=int, default=640, help="crop height") parser.add_argument('--crop_width', type=int, default=768, help="crop width") parser.add_argument('--resume', type=str, default='', help="resume from saved model") parser.add_argument('--start_epoch', type=int, default=0, help='the epoch to resume training') parser.add_argument('--pretrained', dest='pretrained', default=None, help='path to pre-trained model')

    parser.add_argument('--batch_size', type=int, default=8, help='training batch size') parser.add_argument('--val_batch_size', type=int, default=8, help='testing batch size') parser.add_argument('--workers', type=int, default=32, help='number of threads') parser.add_argument('--nEpochs', type=int, default=64, help='number of epochs to train for') parser.add_argument('--solver', default='adam',choices=['adam','sgd'], help='solver algorithms') parser.add_argument('--lr', type=float, default=0.0008, help='Learning Rate. Default=0.001') parser.add_argument('--lr_decay', type=float, default=0.5, help='Learning Rate descending rete. Default=0.5')

    ''' Attention: milestones should be ignored(keep unchanged), since it's adapted to nEpochs in the latter main function ''' #####parser.add_argument('--milestones', default=[14,28,42,56], metavar='N', nargs='', help='epochs at which learning rate is divided by 2')
    parser.add_argument('--milestones', default=[10,20,30,40,50,60], metavar='N', nargs='
    ', help='epochs at which learning rate is divided by 2') #parser.add_argument('--milestones', default=[13,23,33,43,53,63], metavar='N', nargs='*', help='epochs at which learning rate is divided by 2')

    #parser.add_argument('--weight_decay', '--wd', default=4e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--weight_decay', '--wd', default=1e-4, type=float, metavar='W', help='weight decay') parser.add_argument('--bias_decay', default=0, type=float, metavar='B', help='bias decay') parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum for sgd, alpha parameter for adam') parser.add_argument('--beta', default=0.999, type=float, metavar='M', help='beta parameter for adam')

    ''' ascending order means use loss.sum()/batchSize, which is map level average descending order means use loss.mean(), which is pixel level average ''' #parser.add_argument('--multiscale_weights', '-w', default=[0.005,0.01,0.02,0.08,0.32], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) #parser.add_argument('--multiscale_weights', '-w', default=[0.32,0.08,0.02,0.01,0.005], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6')) parser.add_argument('--multiscale_weights', '-w', default=[1./3, 2./3, 1., 1., 1.], type=float, nargs=5, help='training weight for each scale, from highest resolution (flow2) to lowest (flow6)', metavar=('W2', 'W3', 'W4', 'W5', 'W6'))

    parser.add_argument('--seed', type=int, default=2022, help='random seed to use. Default=123')

    parser.add_argument('--print_freq', '-p', default=50, type=int, metavar='N', help='print frequency') parser.add_argument('--save_freq', '-s', default=5, type=int, metavar='N', help='save checkpoint frequency') device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    def main():

    args = parser.parse_args()
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
    print('=> get test data pairs')
    # args.data_path="/home/notebook/data/group/liulibo/stereoProject/rectify/bars/"
    # args.data_path="/home/notebook/data/group/liulibo/MiDaS/langan_refine_data/"
    args.data_path="/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/"
    
    args.flip_LR=0
    args.useMinMax=0
    lists  =[args.data_path+file  for file in os.listdir(args.data_path)  if(("left"  in file  or "master"  in file)  and "disp"  not in file)]
    total  = len(lists)
    print(total)
    #pause
    
    print('=> get models from configuration file')
    content = getYamlCfg(fn='configs/configModelTest.yaml')
    model = LightStereo(parser)
    model = model.to(device).eval()
    # model   = loadPretrain(model, "./checkpoint/refiner_finetune_20240918/model_best.pth.tar", strict=False)
    model   = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
    print('=> infer')
    count=0
    # for idx in range(total):
    for file in os.listdir(args.data_path):  
        if(("left"  in file  or "master"  in file)):
            if "Disp"   in file:
                continue
            try:
                srcLFn    = args.data_path+file
                srcRFn    = srcLFn.replace('left','right').replace('master', 'slave')
                print(srcLFn)
                print(srcRFn)
                lImg      = cv2.imread(srcLFn,1)
                rImg      = cv2.imread(srcRFn,1)
                h,w,c=lImg.shape
                hh,ww,cc=rImg.shape
                lMask     = ((lImg[:,:,0]==0) & (lImg[:,:,1]==0) & (lImg[:,:,2]==0)).astype(np.uint8)
            except:
                continue
            if args.flip_LR>0:
                lImg  = lImg[:,::-1,:]
                rImg  = rImg[:,::-1,:]
                lMask = lMask[:,::-1]
    
            rszH,rszW = lImg.shape[0],lImg.shape[1]
            lImg,rImg = resizer(lImg,rImg,args)
    
            # if args.rgbOrder > 0:
            #     lImg= lImg[:,:,::-1].copy()
            #     rImg= rImg[:,:,::-1].copy()
            # if args.imageNetInputNorm <= 0:
            #     imgPair   = normer(lImg, rImg)
            # else:
            #     if args.constantNorm:
            #         imgPair   = constantNorm(lImg, rImg)
            #     else:
            imgPair   = normerImageNet(lImg, rImg)
            
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():        
                output= model(imgPairTs)
    
            if isinstance(output, list):
                output    = output[-1].squeeze().cpu().numpy()
            else:
                output    = output.squeeze().cpu().numpy()
            if args.flip_LR>0:
                output    = output[:,::-1]
                lMask     = lMask[:,::-1]
    
            outH,outW = output.shape[0],output.shape[1]
            scaleDisp = rszW * 1. / outW
    
            output    = cv2.resize(output, (rszW,rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
            #print(output.min())
    
            # dispU16   = dispFloatToUint16(output, ratio=3)
            output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
            cv2.imwrite(output_path +'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','pred').replace('master','pred').replace('.jpg','.png'), output*10)
    
            # print(args.save_path)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp_gray').replace('master','gru_leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','gru_leftDisp').replace('master','gru_leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
            # cv2.imwrite(args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp_gray').replace('master','leftDisp_gray').replace('.jpg','.png'), dispU16)
            # color     = save_float_to_colormap(output, saveFn=args.data_path+'/'+os.path.basename(srcLFn).replace('left','leftDisp').replace('master','leftDisp').replace('.jpg','.png'), inputLimMin=0, inputLimMax=120, useMinMaxFirst=(args.useMinMax>0), saveU8=False)
        
    

    if name == 'main': main()

    对于这个代码,在处理图像之前,先读取目标文件夹中含有后缀‘_pred’的文件列表,并得到basename,如果需要处理的文件名中含有该basename,则不处理,依次达到只处理遗漏数据的目的

  22. Assistant

    为了在处理图像之前过滤掉已经保存的 _pred 文件,您可以在 main 函数的开头部分加入一个读取目标文件夹中所有已处理文件(即包含 _pred 后缀的文件)的列表,然后在读取每一个需要处理的文件时,检查其 basename 是否在已处理文件中。

    以下是代码修改的示例:

    def main():
        args = parser.parse_args()
    
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        print('=> get test data pairs')
    
        # 目标文件夹路径
        output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
        
        # 获取包含_pred后缀的所有文件名
        processed_files = {os.path.basename(file) for file in glob.glob(os.path.join(output_path, '*_pred*.png'))}
    
        # 路径改为需要处理的图像文件夹
        args.data_path = "/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/"
    
        # 获取所有需要处理的图像文件列表
        lists = [args.data_path + file for file in os.listdir(args.data_path) if ("left" in file or "master" in file) and "disp" not in file]
        
        total = len(lists)
        print(f'Total image pairs: {total // 2}')  # 计算图像对数量
    
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        count = 0
    
        for file in lists:
            # 解析文件名
            if "left" in file:
                srcLFn = file
                srcRFn = srcLFn.replace('left', 'right').replace('master', 'slave')
            else:
                continue
    
            # 获取文件的 basename
            basename = os.path.basename(srcLFn).replace('left', '').replace('.jpg', '').replace('.png', '')
    
            # 检查是否已处理过
            if basename in processed_files:
                print(f'Skipping already processed files for basename: {basename}')
                continue
    
            print(srcLFn)
            print(srcRFn)
    
            # 读取左图和右图
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
    
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} or {srcRFn}')
                continue
    
            h, w, c = lImg.shape
            hh, ww, cc = rImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
    
            if args.flip_LR > 0:
                lImg = lImg[:, ::-1, :]
                rImg = rImg[:, ::-1, :]
                lMask = lMask[:, ::-1]
    
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
    
            imgPair = normerImageNet(lImg, rImg)
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
    
            if args.flip_LR > 0:
                output = output[:, ::-1]
                lMask = lMask[:, ::-1]
    
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
    
            # 保存结果
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    
    if __name__ == '__main__':
        main()
    

    主要修改点:

    1. 获取已处理文件: 使用 glob.glob 函数读取目标文件夹中所有包含 _pred 后缀的文件,并存储其 basename 到 processed_files 集合中。

    2. 检查是否已处理: 在处理每一对图像文件时,通过当前文件的 basename 检查其是否已在 processed_files 集合中。如果是,则打印一条消息并跳过该文件的处理。

    3. 文件路径的处理: 在确定左图和右图路径时,保持之前代码的处理逻辑,并确保 basename 的替换处理正确。

    这样,程序将仅处理未经过的图像,避免重复工作。希望这些修改能够满足你的需求!

  23. User

    是去除_pred作为basename

  24. Assistant

    如果您希望在决定跳过已经处理过的图像时去除 _pred 后缀以得到基路径(basename),您可以在读取目标文件夹中的文件时进行一次简单的字符串处理,将所有 _pred 后缀移除。这样,您可以通过更简单的比较方式来过滤出已经处理过的文件。

    以下是相应的代码修改:

    def main():
        args = parser.parse_args()
    
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        print('=> get test data pairs')
    
        # 目标文件夹路径
        output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
    
        # 获取包含_pred后缀的所有文件名,并去除_pred作为basename
        processed_files = {os.path.basename(file).replace('_pred', '') for file in glob.glob(os.path.join(output_path, '*_pred*.png'))}
    
        # 路径改为需要处理的图像文件夹
        args.data_path = "/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/"
    
        # 获取所有需要处理的图像文件列表
        lists = [args.data_path + file for file in os.listdir(args.data_path) if ("left" in file or "master" in file) and "disp" not in file]
        
        total = len(lists)
        print(f'Total image pairs: {total // 2}')  # 计算图像对数量
    
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        count = 0
    
        for file in lists:
            # 解析文件名
            if "left" in file:
                srcLFn = file
                srcRFn = srcLFn.replace('left', 'right').replace('master', 'slave')
            else:
                continue
    
            # 获取文件的 basename,去除 `_pred`
            basename = os.path.basename(srcLFn).replace('left', '').replace('.jpg', '').replace('.png', '')
    
            # 检查是否已处理过,去除_pred
            if basename in processed_files:
                print(f'Skipping already processed files for basename: {basename}')
                continue
    
            print(srcLFn)
            print(srcRFn)
    
            # 读取左图和右图
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
    
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} or {srcRFn}')
                continue
    
            h, w, c = lImg.shape
            hh, ww, cc = rImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
    
            if args.flip_LR > 0:
                lImg = lImg[:, ::-1, :]
                rImg = rImg[:, ::-1, :]
                lMask = lMask[:, ::-1]
    
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
    
            imgPair = normerImageNet(lImg, rImg)
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
    
            if args.flip_LR > 0:
                output = output[:, ::-1]
                lMask = lMask[:, ::-1]
    
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
    
            # 保存结果
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    
    if __name__ == '__main__':
        main()
    

    代码的主要修改点:

    1. 去除 _pred 后缀: 在 processed_files 集合中,将 os.path.basename(file) 中的 _pred 替换掉,并将结果存储。这样可以确保基路径用于后续比较。

    2. 获取 basename: 在检查是否已处理时,直接使用提取到的 basename,并去除 left 和文件扩展名(.jpg 或 .png)。

    这种方式确保您只处理那些尚未完成的图像对,实现了只处理遗漏数据的目的。希望这些修改对您有帮助!

  25. User

    是读取需要处理的数据,并且将它的basename保存成一个列表,并把其中符合pred的basename的路径去除,再进行处理。需要注意的是,这里的文件名因为有10和1000这种格式,必须要完全符合才去除

  26. Assistant

    明白了,您希望读取需要处理的文件名,然后将符合 _pred 后缀的文件名称提取出来,并与待处理文件的 basename 进行精确匹配,以决定是否跳过处理这些文件。下面是实现这一要求的代码示例:

    代码修改示例

    def main():
        args = parser.parse_args()
    
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        print('=> get test data pairs')
    
        # 目标文件夹路径
        output_path = '/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/'
    
        # 获取所有带有 *_pred* 后缀的文件,并提取其 basename
        processed_files = {os.path.basename(file).replace('_pred', '') for file in glob.glob(os.path.join(output_path, '*_pred*.png'))}
    
        # 路径改为需要处理的图像文件夹
        args.data_path = "/home/notebook/data/group/Ruby/langan_datasets/shoushi/shoushi_crop_s/mono/"
    
        # 获取所有需要处理的图像文件列表
        lists = [args.data_path + file for file in os.listdir(args.data_path) if ("left" in file or "master" in file) and "disp" not in file]
        
        total = len(lists)
        print(f'Total image pairs: {total // 2}')  # 计算图像对数量
    
        print('=> get models from configuration file')
        content = getYamlCfg(fn='configs/configModelTest.yaml')
        model = LightStereo(parser)
        model = model.to(device).eval()
        model = loadPretrain(model, "./checkpoint/gru/best.pth.tar", strict=False)
    
        print('=> infer')
        count = 0
    
        for file in lists:
            # 解析文件名
            if "left" in file:
                srcLFn = file
                srcRFn = srcLFn.replace('left', 'right').replace('master', 'slave')
            else:
                continue
    
            # 获取文件的 basename
            basename = os.path.basename(srcLFn).replace('left', '').replace('.jpg', '').replace('.png', '')
    
            # 检查是否已处理过
            if basename in processed_files:
                print(f'Skipping already processed files for basename: {basename}')
                continue
    
            print(srcLFn)
            print(srcRFn)
    
            # 读取左图和右图
            lImg = cv2.imread(srcLFn, 1)
            rImg = cv2.imread(srcRFn, 1)
    
            if lImg is None or rImg is None:
                print(f'Error reading images: {srcLFn} or {srcRFn}')
                continue
    
            h, w, c = lImg.shape
            hh, ww, cc = rImg.shape
            lMask = ((lImg[:, :, 0] == 0) & (lImg[:, :, 1] == 0) & (lImg[:, :, 2] == 0)).astype(np.uint8)
    
            if args.flip_LR > 0:
                lImg = lImg[:, ::-1, :]
                rImg = rImg[:, ::-1, :]
                lMask = lMask[:, ::-1]
    
            rszH, rszW = lImg.shape[0], lImg.shape[1]
            lImg, rImg = resizer(lImg, rImg, args)
    
            imgPair = normerImageNet(lImg, rImg)
            imgPairTs = torch.from_numpy(imgPair).to(device).float().unsqueeze(0)
    
            with torch.no_grad():
                output = model(imgPairTs)
    
            if isinstance(output, list):
                output = output[-1].squeeze().cpu().numpy()
            else:
                output = output.squeeze().cpu().numpy()
    
            if args.flip_LR > 0:
                output = output[:, ::-1]
                lMask = lMask[:, ::-1]
    
            outH, outW = output.shape[0], output.shape[1]
            scaleDisp = rszW * 1. / outW
            output = cv2.resize(output, (rszW, rszH), interpolation=cv2.INTER_LINEAR) * scaleDisp
    
            # 保存结果
            cv2.imwrite(output_path + '/' + os.path.basename(srcLFn).replace('left', 'pred').replace('master', 'pred').replace('.jpg', '.png'), output * 10)
    
    if __name__ == '__main__':
        main()
    

    主要修改点:

    1. 提取已处理文件名:

      • 使用 glob.glob() 获取所有带有 _pred 后缀的文件路径。
      • 在提取时,去除 _pred 后缀并存储为集合 processed_files,以进行后续精确匹配。
    2. 检查已处理的文件:

      • 在处理每个图像时,检查与 basename 相等的条目是否存在于 processed_files 集合中。只有当它确实存在时才会跳过这张图像。
    3. basename 的提取格式:

      • 在提取 basename 时,确保只去除与文件名结构相关的部分,而不影响实际处理逻辑。

    这个实现确保了只有那些未处理的图像(即其 basename 不在 _pred 文件名列表中)会被处理,从而避免重复计算和节约处理时间。希望这个实现符合您的要求!