Projeto Prático de Visão Computacional 2 (Rastreio Monocular + Processamento de Imagem + Planejamento de Caminho + Reconhecimento de Placas)

Reconhecimento de matrículas

O reconhecimento de placas chinesas usando python3 + opencv3, incluindo algoritmo e interface do cliente, possui apenas 2 arquivos, um é o código da interface e o outro é o código do algoritmo. Os resultados podem ser obtidos clicando nele, o que é conveniente e fácil de usar !
Link: Reconhecimento de placas de veículos
A interface geral da UI é a seguinte: Clique para entrar na imagem e os resultados aparecerão à direita!

código

Nota adicional: O código do algoritmo possui apenas 500 linhas. Durante o teste, constatou-se que os parâmetros do algoritmo de posicionamento de placas são afetados pela resolução da imagem, mudança de cor e distância do veículo.

--->qq 1309399183----------<代码交流
	def from_pic(self):
		self.thread_run = False
		self.pic_path = askopenfilename(title="选择识别图片", filetypes=[("jpg图片", "*.jpg")])
		if self.pic_path:
			img_bgr = predict.imreadex(self.pic_path)
			self.imgtk = self.get_imgtk(img_bgr)
			self.image_ctl.configure(image=self.imgtk)
			resize_rates = (1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4)
			for resize_rate in resize_rates:
				print("resize_rate:", resize_rate)
				r, roi, color = self.predictor.predict(img_bgr, resize_rate)
				if r:
					break
			#r, roi, color = self.predictor.predict(img_bgr, 1)
			self.show_roi(r, roi, color)

Combinação de neblina de imagem e remoção de chuva + detecção de alvo + alcance monocular

A percepção em tempo real da distância dos objetos ao redor do veículo é de grande importância para os sistemas avançados de assistência à direção.Quando é determinado que a distância entre o objeto e o veículo é inferior a uma distância segura, as funções de assistência à segurança, como a frenagem ativa
, serão ser adotado, o que melhorará ainda mais o desempenho de segurança do veículo e reduzirá a ocorrência de colisões. No capítulo anterior, este artigo completou a tarefa de detecção de alvos. Em seguida, precisamos medir a distância dos objetos detectados.

• Primeiro, o modelo de imagem da câmera é descrito e analisado, e a relação entre o sistema de coordenadas de pixel da imagem e o sistema de coordenadas mundial é derivada.
• Em segundo lugar, a calibração do software é usada para obter os parâmetros internos e externos da câmera e a seleção dos pontos alvo é melhorada.
• Por fim, o modelo de medição de distância é utilizado para completar a medição de distância e as imagens coletadas são simuladas e analisadas e o método é verificado.

código

        for path, img, im0s, vid_cap in dataset:
        img = torch.from_numpy(img).to(device)
        img = img.half() if half else img.float()  # uint8 to fp16/32
        img /= 255.0  # 0 - 255 to 0.0 - 1.0
        if img.ndimension() == 3:
            img = img.unsqueeze(0)

        # Warmup
        if device.type != 'cpu' and (old_img_b != img.shape[0] or old_img_h != img.shape[2] or old_img_w != img.shape[3]):
            old_img_b = img.shape[0]
            old_img_h = img.shape[2]
            old_img_w = img.shape[3]
            for i in range(3):
                model(img, augment=opt.augment)[0]

        # Inference
        t1 = time_synchronized()
        with torch.no_grad():   # Calculating gradients would cause a GPU memory leak
            pred = model(img, augment=opt.augment)[0]
        t2 = time_synchronized()
         distance=object_point_world_position(u, v, h, w, out_mat, in_mat):

plano de rota

Nesta seção, para o problema de planejamento de caminhos em cenários off-road, o método de grade é usado para estabelecer obstáculos, ameaças e modelos de estradas off-road para simular cenários reais de ambiente off-road.

• A penalidade de mudança de direção e a penalidade de complexidade de área local são introduzidas para otimizar o algoritmo A, tornando o caminho planejado pelo algoritmo mais suave e a eficiência do algoritmo mais eficiente.

• O algoritmo Floyd aprimorado é usado para suavizar o caminho em ambas as direções, e o processamento anticolisão é executado para garantir a segurança e confiabilidade do caminho planejado.

• Os resultados da simulação mostram que, em comparação com o algoritmo tradicional, o algoritmo A aprimorado melhorou a eficiência em 30% e reduziu o número de pontos de inflexão em 4 vezes. O
  algoritmo proposto pode operar rapidamente sob a influência abrangente de múltiplos fatores no off-road ambiente e os requisitos de diferentes desempenhos e tarefas do veículo. Planeje um caminho seguro.

código

###############创建A-Star类############
class AStar:
    
    # 描述AStar算法中的节点数据
    class Node:  
        #初始化
        def __init__(self, point, startPoint,endPoint, g=0,w=1,p=1):
            self.point = point  # 自己的坐标
            self.father = None  # 父节点
            self.g = g       # g值，g值在用到的时候会重新算
            
            # 计算h值，采用曼哈顿距离
            #self.h = (abs(endPoint.x - point.x) + abs(endPoint.y - point.y)) * 10  
            
            #采用欧几里得距离
            #self.h = math.pow((math.pow((endPoint.x - point.x),2) + math.pow((endPoint.y - point.y),2)),0.5)*10
            
            #采用对角距离
            pp=(1-p)+0.2*math.exp((math.pow((math.pow((endPoint.x - point.x),2) + math.pow((endPoint.y - point.y),2)),0.5))/(math.pow((math.pow((endPoint.x - startPoint.x),2) + math.pow((endPoint.y - startPoint.y),2)),0.5)))
            Diagonal_step = min((endPoint.x - point.x),(endPoint.y - point.y))
            straight_step = (abs(endPoint.x - point.x) + abs(endPoint.y - point.y)) - 2*Diagonal_step
            self.h  =(straight_step + math.pow(2,0.5)*Diagonal_step)*10*pp
            #print(pp)


            
    #初始化A-start
    def __init__(self, map2d, startPoint, endPoint, passTag=1.0):#map2d地图信息，startPoint起点, endPoint终点, passTag=1.0为不可行驶区域

        # 开启表
        self.openList = []
        # 关闭表
        self.closeList = []
        # 寻路地图
        self.map2d = map2d
        # 起点终点
        if isinstance(startPoint, Point) and isinstance(endPoint, Point):
            self.startPoint = startPoint
            self.endPoint = endPoint
        else:
            self.startPoint = Point(*startPoint)
            self.endPoint = Point(*endPoint)
 
        # 不可行走标记
        self.passTag = passTag
 
    def getMinNode(self):
        """
        获得openlist中F值最小的节点
        :return: Node
        """
        currentNode = self.openList[0]
        for node in self.openList:
            if node.g + node.h < currentNode.g + currentNode.h:
                currentNode = node
        return currentNode#返回最小代价的点
 

Detecção de vaga de estacionamento

A detecção e classificação de pontos de estacionamento com base em aprendizado profundo em imagens olho de peixe são desenvolvidas para detecção de objetos 2D. Nosso trabalho aprimora a capacidade de prever pontos e caixas-chave. Isto é útil em muitos cenários onde os objetos não podem ser representados "firmemente" pelo retângulo superior direito.
Um exemplo, quaisquer marcações na estrada, objetos retangulares no mundo real não permanecerão retangulares na imagem devido aos efeitos de perspectiva, portanto a detecção de pontos-chave é particularmente importante. As imagens olho de peixe também apresentam outro cenário em que esse fenômeno foi observado, permitindo a captura de mais imagens devido ao amplo ângulo de visão do olho de peixe.

Link: Detecção de vaga de estacionamento

código

#全部代码可加qq1309399183
def train():
    #parses command line args
    args = parse_args()

    #parses args from file
    if args.config_file is not None:
        cfg_from_file(args.config_file)

    if (args.FIX_MODEL_CHECKPOINT):
      args.FIX_MODEL_CHECKPOINT = args.FIX_MODEL_CHECKPOINT.replace(" ", "")
      args.FIX_MODEL_CHECKPOINT = args.FIX_MODEL_CHECKPOINT.replace("=", "")
      cfg.RESUME_CHECKPOINT = args.FIX_MODEL_CHECKPOINT
      cfg.CHECK_PREVIOUS = False
      if (os.path.exists(cfg.RESUME_CHECKPOINT) == False):
          print('Exiting the process as asked model for resuming is not found')
          exit()

    if (args.RESUME_CHECKPOINT):
      cfg.RESUME_CHECKPOINT = args.RESUME_CHECKPOINT

    if (args.LOG_DIR):
      cfg.EXP_DIR = args.LOG_DIR

    cfg.LOG_DIR = cfg.EXP_DIR

    if (args.PHASE):
      cfg.PHASE = []
      cfg.PHASE.append(args.PHASE)

    if (args.EVAL_METHOD):
      cfg.DATASET.EVAL_METHOD = args.EVAL_METHOD

    #for backward compatibility
    if cfg.DATASET.DATASET == 'psd':
      cfg.DATASET.DATASET = 'tiod'

    if cfg.DATASET.BGR_OR_RGB == True:
        #cfg.DATASET.PIXEL_MEANS = (123.68, 116.78, 103.94)
        #cfg.DATASET.PIXEL_MEANS = (123, 117, 104)
        cfg.DATASET.PIXEL_MEANS = (128.0, 128.0, 128.0) # simpler mean subtraction to keep data in int8 after mean subtraction

    print("cfg: ", cfg)

    for phase in cfg.PHASE:
      cfg_dir = cfg.LOG_DIR + '/' + phase + '_cfg/'
      os.makedirs(os.path.dirname(cfg_dir), exist_ok=True)
      shutil.copy(args.config_file, cfg_dir)

    # to making every run consistent # TII
    np.random.seed(100)
    torch.manual_seed(100)
    torch.cuda.manual_seed(100)
    random.seed(100)
    torch.cuda.manual_seed_all(999)
    torch.backends.cudnn.enabled = False

    train_model()

if __name__ == '__main__':
    train()

Remoção de névoa de imagem e detecção de alvo

Diferentes métodos de pré-processamento de imagem são adotados para diferentes condições climáticas para melhorar a qualidade da imagem. Em tempo de neblina, a transmitância atualmente calculada causará halos e artefatos nos resultados de desembaçamento. Este artigo usa o método dos mínimos quadrados ponderados para refinar a transmitância. A fim de resolver o problema de valores imprecisos de luz atmosférica obtidos pelo método quadtree, o método quadtree é aprimorado para resolver os problemas acima. Substitua os valores de transmitância e luz atmosférica obtidos acima no modelo de espalhamento atmosférico para completar o processo de desembaçamento;

Adicionar a detecção de alvos após o processamento da imagem melhora a precisão da detecção de alvos e o número de alvos.
A figura abaixo mostra os resultados após o processamento do tempo de neblina.
A primeira coluna da figura é a imagem de neblina, a segunda coluna é a imagem do resultado da detecção do alvo sem processamento de imagem e a terceira coluna é a imagem do resultado da detecção do alvo após o desembaçamento.