基于卷积神经网络＆深度学习的车距检测系统

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    import xml.etree.ElementTree as ET
    import os
    
    classes = []  # 初始化为空列表
    
    CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
    
    def convert(size, box):
    dw = 1. / size[0]
    dh = 1. / size[1]
    x = (box[0] + box[1]) / 2.0
    y = (box[2] + box[3]) / 2.0
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return (x, y, w, h)
    
    def convert_annotation(image_id):
    in_file = open('./label_xml\%s.xml' % (image_id), encoding='UTF-8')
    out_file = open('./label_txt\%s.txt' % (image_id), 'w')  # 生成txt格式文件
    tree = ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)
    
    for obj in root.iter('object'):
        cls = obj.find('name').text
        if cls not in classes:
            classes.append(cls)  # 如果类别不存在，添加到classes列表中
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
             float(xmlbox.find('ymax').text))
        bb = convert((w, h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    
    xml_path = os.path.join(CURRENT_DIR, './label_xml/')
    
    # xml list
    img_xmls = os.listdir(xml_path)
    for img_xml in img_xmls:
    label_name = img_xml.split('.')[0]
    print(label_name)
    convert_annotation(label_name)
    
    print("Classes:")  # 打印最终的classes列表
    print(classes)  # 打印最终的classes列表
    
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/Mj581pCrIZNKdmiy97Eo3sJXBQSe.png)

    -----data
       |-----train
       |   |-----images
       |   |-----labels
||

       |-----valid
       |   |-----images
       |   |-----labels
||

       |-----test
       |-----images
       |-----labels
    
    
    
    AI生成项目
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/Ds5LHcvmRBEkIloKQnja1P4wCf9N.png)

     Epoch   gpu_mem       box       obj       cls    labels  img_size
     1/200     20.8G   0.01576   0.01955  0.007536        22      1280: 100%|██████████| 849/849 [14:42<00:00,  1.04s/it]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|██████████| 213/213 [01:14<00:00,  2.87it/s]
             all       3395      17314      0.994      0.957      0.0957      0.0843
    
     Epoch   gpu_mem       box       obj       cls    labels  img_size
     2/200     20.8G   0.01578   0.01923  0.007006        22      1280: 100%|██████████| 849/849 [14:44<00:00,  1.04s/it]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|██████████| 213/213 [01:12<00:00,  2.95it/s]
             all       3395      17314      0.996      0.956      0.0957      0.0845
    
     Epoch   gpu_mem       box       obj       cls    labels  img_size
     3/200     20.8G   0.01561    0.0191  0.006895        27      1280: 100%|██████████| 849/849 [10:56<00:00,  1.29it/s]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|███████   | 187/213 [00:52<00:00,  4.04it/s]
             all       3395      17314      0.996      0.957      0.0957      0.0845
    
    
    AI生成项目
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/5OuY81k3pGJQehPSUtbRW6m4y9rE.png)

    
    class DistanceMeasurer:
    def __init__(self):
        self.mtcnn = MTCNN()
        self.p4p = P4P()
    
    def measure_distance(self, image, detections):
        distances = []
        for detection in detections:
            landmarks = self.mtcnn.detect_landmarks(image, detection)
            distance = self.p4p.calculate_distance(landmarks)
            distances.append(distance)
    
        return distances
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/RleTZuf3mnk6UjPsqbH4DiQd81V2.png)

    
    
    class YOLOv5Exporter:
    def __init__(self, weights, include):
        self.weights = weights
        self.include = include
    
    def export(self):
        set_logging()
        device = select_device('')
        half = device.type != 'cpu'  # half precision only supported on CUDA
    
        # Load model
        model = attempt_load(self.weights, map_location=device)  # load FP32 model
        imgsz = check_img_size(640, s=model.stride.max())  # check img_size
        if half:
            model.half()  # to FP16
    
        # Set Dataloader
        dataset = LoadImages('data/images', img_size=imgsz)
    
        # Configure run
        model.eval()
    
        # Export
        if 'torchscript' in self.include:
            export_torchscript(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''), optimize=True)
        if 'onnx' in self.include:
            export_onnx(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''), opset=12, train=False, dynamic=False, simplify=False)
        if 'coreml' in self.include:
            export_coreml(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''))
        if 'saved_model' in self.include:
            export_saved_model(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''), dynamic=False)
        if 'pb' in self.include:
            export_pb(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''))
        if 'tflite' in self.include:
            export_tflite(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''), int8=False, data='data.yaml', ncalib=100)
        if 'tfjs' in self.include:
            export_tfjs(model, torch.zeros(1, 3, imgsz, imgsz).to(device), Path(''))
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/TmcCjhf3oBtREK4uNkIlqQDVSi8x.png)

    import numpy as np
    import cv2
    
    class P4P:
    def __init__(self, camera_matrix, dist_coeffs):
        self.camera_matrix = camera_matrix
        self.dist_coeffs = dist_coeffs
    
    def calculate_distance(self, image_points, object_points):
        _, rotation_vector, translation_vector = cv2.solvePnP(object_points, image_points,
                                                              self.camera_matrix, self.dist_coeffs)
        distance = translation_vector[2]
        return distance
    
    
    
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/fS3ax75ZETKUz1vyNPjskmoR04Bu.png)

    
    class CarDetector:
    def __init__(self, model_path):
        self.model = attempt_load(model_path, map_location=torch.device('cpu')).eval()
    
    def detect_cars(self, img_path):
        img = cv2.imread(img_path)
        img = torch.from_numpy(img.transpose(2, 0, 1)).float() / 255.0
        img = img.unsqueeze(0)
    
        # Run YOLOv5 detector
        pred = self.model(img)[0]
    
        # Apply non-maximum suppression
        pred = non_max_suppression(pred, conf_thres=0.25, iou_thres=0.45)
    
        # Get car bounding boxes
        car_boxes = []
        for det in pred:
            for x1, y1, x2, y2, conf, cls in det:
                if int(cls) == 2:  # Class ID 2 represents cars
                    car_boxes.append((x1.item(), y1.item(), x2.item(), y2.item()))
    
        return car_boxes
    
    def calculate_car_distance(self, img_path, real_car_height, known_distance):
        img = cv2.imread(img_path)
        img_height, img_width = img.shape[:2]
    
        car_boxes = self.detect_cars(img_path)
    
        car_distances = []
        for x1, y1, x2, y2 in car_boxes:
            bbox_height = y2 - y1
            distance = (real_car_height * known_distance) / bbox_height
            car_distances.append(distance)
    
        return car_distances
    ......
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/mdu3eL8JSVvlxUF1RM2Y7ifOQcXq.png)

    class YOLOv5Validator:
    def __init__(self, data, weights=None, batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.6, task='val', device='', single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=False, project=ROOT / 'runs/val', name='exp', exist_ok=False, half=True, model=None, dataloader=None, save_dir=Path(''), plots=True, callbacks=Callbacks(), compute_loss=None):
        self.data = data
        self.weights = weights
        self.batch_size = batch_size
        self.imgsz = imgsz
        self.conf_thres = conf_thres
        self.iou_thres = iou_thres
        self.task = task
        self.device = device
        self.single_cls = single_cls
        self.augment = augment
        self.verbose = verbose
        self.save_txt = save_txt
        self.save_hybrid = save_hybrid
        self.save_conf = save_conf
        self.save_json = save_json
        self.project = project
        self.name = name
        self.exist_ok = exist_ok
        self.half = half
        self.model = model
        self.dataloader = dataloader
        self.save_dir = save_dir
        self.plots = plots
        self.callbacks = callbacks
        self.compute_loss = compute_loss
    
    def save_one_txt(self, predn, save_conf, shape, file):
        # Save one txt result
        gn = torch.tensor(shape)[[1, 0, 1, 0]]  # normalization gain whwh
        for *xyxy, conf, cls in predn.tolist():
            xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # normalized xywh
            line = (cls, *xywh, conf) if save_conf else (cls, *xywh)  # label format
            with open(file, 'a') as f:
                f.write(('%g ' * len(line)).rstrip() % line + '\n')
    
    def save_one_json(self, predn, jdict, path, class_map):
        # Save one JSON result {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
        image_id = int(path.stem) if path.stem.isnumeric() else path.stem
        box = xyxy2xywh(predn[:, :4])  # xywh
        box[:, :2] -= box[:, 2:] / 2  # xy center to top-left corner
        for p, b in zip(predn.tolist(), box.tolist()):
            jdict.append({'image_id': image_id,
                          'category_id': class_map[int(p[5])],
                          'bbox': [round(x, 3) for x in b],
                          'score': round(p[4], 5)})
    
    def process_batch(self, detections, labels, iouv):
        """
        Return correct predictions matrix. Both sets of boxes are in (x1, y1, x2, y2) format.
        Arguments:
            detections (Array[N, 6]), x1, y1, x2, y2, conf, class
            labels (Array[M, 5]), class, x1, y1, x2, y2
        Returns:
            correct (Array[N, 10]), for 10 IoU levels
        """
        correct = torch.zeros(detections.shape[0], iouv.shape[0], dtype=torch.bool, device=iouv.device)
        iou = box_iou(labels[:, 1:], detections[:, :4])
        x = torch.where((iou >= iouv[0]) & (labels[:, 0:1] == detections[:, 5]))  # IoU above threshold and classes match
        if x[0].shape[0]:
            matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()  # [label, detection, iou]
            if x[0].shape[0] > 1:
                matches = matches[matches[:, 2].argsort()[::-1]]
                matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
                # matches = matches[matches[:, 2].argsort()[::-1]]
                matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
            matches = torch.Tensor(matches).to(iouv.device)
            correct[matches[:, 1].long()] = matches[:, 2:3] >= iouv
        return correct
    
    @torch.no_grad()
    def run(self):
        # Initialize/load model and set device
        training = self.model is not None
        if training:  # called by train.py
            device = next(self.model.parameters()).device  # get model device
    
        else:  # called directly
            device = select_device(self.device, batch_size=self.batch_size)
    
            # Directories
            self.save_dir = increment_path(Path(self.project) / self.name, exist_ok=self.exist_ok)  # increment run
            (self.save_dir / 'labels' if self.save_txt else self.save_dir).mkdir(parents=True, exist_ok=True)  # make dir
    
            # Load model
            check_suffix(self.weights, '.pt')
            self.model = attempt_load(self.weights, map_location=device)  # load FP32 model
            gs = max(int(self.model.stride.max()), 32)  # grid size (max stride)
            self.imgsz = check_img_size(self.imgsz, s=gs)  # check image size
    
            # Multi-GPU disabled, incompatible with .half() https://github.com/ultralytics/yolov5/issues/99
            # if device.type != 'cpu' and torch.cuda.device_count() > 1:
            #     model = nn.DataParallel(model)
    
            # Data
            self.data = check_dataset(self.data)  # check
    
        # Half
        self.half &= device.type != 'cpu'  # half precision only supported on CUDA
        self.model.half() if self.half else self.model.float()
    
        # Configure
        self.model.eval()
        is_coco = isinstance(self.data.get('val'), str) and self.data['val'].endswith('coco/val2017.txt')  # COCO dataset
        nc = 1 if self.single_cls else int(self.data['nc'])  # number of classes
        iouv = torch.linspace(0.5, 0.95, 10).to(device)  # iou vector for mAP@0.5:0.95
        niou = iouv.numel()
    
        # Dataloader
        if not training:
            if device.type != 'cpu':
                self.model(torch.zeros(1, 3, self.imgsz, self.imgsz).to(device).type_as(next(self.model.parameters())))  # run once
            pad = 0.0 if self.task == 'speed' else 0.5
            self.task = self.task if self.task in ('train', 'val',
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/6Kk13dio07v4fZmJaxBtFIc9OHQy.png)

    
    class CrossConv(nn.Module):
    # Cross Convolution Downsample
    def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
        # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, (1, k), (1, s))
        self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
        self.add = shortcut and c1 == c2
    
    def forward(self, x):
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
    
    
    class Sum(nn.Module):
    # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
    def __init__(self, n, weight=False):  # n: number of inputs
        super().__init__()
        self.weight = weight  # apply weights boolean
        self.iter = range(n - 1)  # iter object
        if weight:
            self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True)  # layer weights
    
    def forward(self, x):
        y = x[0]  # no weight
        if self.weight:
            w = torch.sigmoid(self.w) 
            for i in self.iter:
                y = y + x[i + 1] * w[i]
        else:
            for i in self.iter:
                y = y + x[i + 1]
        return y
    
    
    class MixConv2d(nn.Module):
    # Mixed Depth-wise Conv https://arxiv.org/abs/1907.09595
    def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
        super().__init__()
        groups = len(k)
        if equal_ch:  # equal c_ per group
            i = torch.linspace(0, groups - 1E-6, c2).floor()  # c2 indices
            c_ = [(i == g).sum() for g in range(groups)]  # intermediate channels
        else:  # equal weight.numel() per group
            b = [c2] + [0] * groups
            a = np.eye(groups + 1, groups, k=-1)
            a -= np.roll(a, 1, axis=1)
            a *= np.array(k) *
            a[0] = 1
            c_ = np.linalg.lstsq(a, b, rcond=None)[0].round()  # solve for equal weight indices, ax = b
    
        self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.LeakyReLU(0.1, inplace=True)
    
    def forward(self, x):
        return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
    
    
    class Ensemble(nn.ModuleList):
    # Ensemble of models
    def __init__(self):
        super().__init__()
    
    def forward(self, x, augment=False, profile=False, visualize=False):
        y = []
        for module in self:
            y.append(module(x, augment, profile, visualize)[0])
        # y = torch.stack(y).max(0)[0]  # max ensemble
        # y = torch.stack(y).mean(0)  # mean ensemble
        y = torch.cat(y, 1)  # nms ensemble
        return y, None  # inference, train output
    
    
    def attempt_load(weights, map_location=None, inplace=True, fuse=True):
    from models.yolo import Detect, Model
    
    # Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
    model = Ensemble()
    for w in weights if isinstance(weights, list) else [weights]:
        ckpt = torch.load(attempt_download(w), map_location=map_location)  # load
        if fuse:
            model.append(ckpt['ema' if ckpt.get('ema') else 'model'].float().fuse().eval())  # FP32 model
        else:
            model.append(ckpt['ema' if ckpt.get('ema') else 'model'].float().eval())  # without layer fuse
    
    
    # Compatibility updates
    for m in model.modules():
        if type(m) in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU, Detect, Model]:
            m.inplace = inplace  # pytorch 1.7.0 compatibility
            if type(m) is Detect:
                if not isinstance(m.anchor_grid, list):  # new Detect Layer compatibility
                    delattr(m, 'anchor_grid')
                    setattr(m, 'anchor_grid', [torch.zeros(1)] * m.nl)
        elif type(m) is Conv:
            m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
    
    if len(model) == 1:
        return model[-1]  # return model
    else:
        print(f'Ensemble created with {weights}\n')
        for k in ['names']:
            setattr(model, k, getattr(model[-1], k))
        model.stride = model[torch.argmax(torch.tensor([m.stride.max() for m in model])).int()].stride  # max stride
        return model  # return ensemble
    
    
    AI生成项目python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/XR0P9BrtkMAHwiFezdV52bKIaOh1.png)