Unity的live2dgalgame多语言可配置剧情框架

news2024/9/23 17:20:39

这段代码用于读取表格

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using OfficeOpenXml;
using System.IO;
using UnityEngine.Networking;
using UnityEngine.UI;
using Random = UnityEngine.Random;
 

public class Plots : MonoBehaviour
{
    public static string ReadingExcel;//正在读取的表格
    [Header("表格文件夹")] public static string URL =  Application.streamingAssetsPath;

    public static string PlotsEXCEL = "Plots";
    private static bool m_loaded;


    
    public  class plot
    {
        public string index, CN,NameCN, NameEN,EN,NameJP, JP,Face;
    }

    public static List<plot> S_Plots= new List<plot>();
    public virtual void OnEnable()
    {
        initialization();
    }

    //初始化
    public void initialization()
    {
        if (!m_loaded)
        {
            LoadExcel();
            m_loaded = true;
        } 

    }

    void LoadExcel()
    {

        //获取Excel文件的信息
        foreach (var VARIABLE in ReadFile())
        {
            Debug.Log("剧情挂载成功");
            FileInfo fileInfo = new FileInfo(VARIABLE);
            //加载背包信息
            if (VARIABLE.Contains(PlotsEXCEL))
            {

                //通过Excel表格的文件信息，打开Excel表格
                //使用using(){}语句命令，在结束时自动关闭文件
                using (ExcelPackage excelPackage = new ExcelPackage(fileInfo))
                {
                    //读取Excel中的第一张表， 注意EPPlus的索引值是从1开始的

                    ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets[1];
                    //取得第一行第一列的数据
//                    Debug.Log("行数"+worksheet.Dimension.End.Row + 1);

                    for (int Left = 2; Left < worksheet.Dimension.End.Row + 1; Left++) //根据行数遍历
                    {
                        
                            if (worksheet.Cells[Left, 1].Value.ToString().Length>0)
                            {
                                plot Plot = new plot();
                                Plot.index= worksheet.Cells[Left, 1].Value.ToString();
                                Plot.Face= worksheet.Cells[Left, 2].Value.ToString();
                                Plot.CN= worksheet.Cells[Left, 3].Value.ToString();
                                Plot.NameCN= worksheet.Cells[Left, 4].Value.ToString();
                                Plot.EN= worksheet.Cells[Left, 5].Value.ToString();
                                Plot.NameEN= worksheet.Cells[Left, 6].Value.ToString();
                                Plot.JP= worksheet.Cells[Left, 7].Value.ToString();
                                Plot.NameJP= worksheet.Cells[Left, 8].Value.ToString();
                                S_Plots.Add(Plot);
                            }

                        
               
                  
                    }
                }


            }
        }

    }

    /// <summary>
    /// 字符串转Enum
    /// </summary>
    /// <typeparam name="T">枚举</typeparam>
    /// <param name="str">字符串</param>
    /// <returns>转换的枚举</returns>
    public static T ToEnum<T>(string str)
    {
        try
        {
            return (T)Enum.Parse(typeof(T), str);
        }
        catch (ArgumentException e)
        {
            Debug.LogError("未找到系列"+str);
            throw;
        }

    }

 
    static List<string> ReadFile()
    {
        List<string> files = GetFiles(URL, "*.xlsx");


        List<string> GetFiles(string directory, string pattern)
        {
            List<string> files = new List<string>();
            foreach (var item in Directory.GetFiles(directory, pattern))
            {
                files.Add(item);
            }

            foreach (var item in Directory.GetDirectories(directory))
            {
                files.AddRange(GetFiles(item, pattern));
            }

            return files;
        }

        return files;
    }
}

这个方法里面设置剧情列表,和分支事件

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text.RegularExpressions;
using DG.Tweening;
using Live2D.Cubism.Rendering;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using UnityEngine;
using UnityEngine.UI;

public class PlotReader : MonoBehaviour
{
   public Button[] ChoiceButton;
   public Text Text_Plot,Text_Name;
   public static int[] PlotBar;
   public static Action PlotFinEvent;
   public Button BTN_NextStep,BTN_Auto,BTN_Skip;
   public bool AutoMode,SkipMode;

   public Button LanguageCN, LanguageEN, LanguageJP;

   public float DomoveOffeset = 100;
   public float DomoveTime=0.1f;
   public GameObject Live2DFolider;

   public int index=0;
   private void Start()
   {
      LanguageCN.onClick.AddListener(()=>
      {
         Center.Language = "CN";
         RefreshLanguage();
      });
      LanguageEN.onClick.AddListener(()=>
      {
         Center.Language = "EN";
         RefreshLanguage();
      });
      LanguageJP.onClick.AddListener(()=>
      {
         Center.Language = "JP";
         RefreshLanguage();
      });
      BTN_Auto.onClick.AddListener(() =>
      {
         AutoMode = !AutoMode;
                  SkipMode = false;
               });
      BTN_Skip.onClick.AddListener(() =>
      {
         SkipMode = !SkipMode;
         AutoMode = false;
      });
      
      BTN_NextStep.onClick.AddListener(PlotNext);
      //注意!!! 剧情要-1,选项要-2
      SetPlotBar(new int[]{0,1,2,3,4,5,6,7},() => MakeChoice(new int[] { 7, 8 ,16}));
      PlotNext();
   }

   private float AutoTimeindex;
   private float AutoTimeMax = 3f;
   private void Update()
   {
      if (AutoMode)
      {
         if (index<=PlotBar.Length)
         {
            AutoTimeindex -= Time.deltaTime;
         }
         if (AutoTimeindex < 0 )
         {
            AutoTimeindex = AutoTimeMax;
            PlotNext();
         }
      }

      if (SkipMode)
      {
         if (index<=PlotBar.Length)
         {
            AutoTimeindex -= Time.deltaTime*20;
         }
         if (AutoTimeindex < 0 )
         {
            AutoTimeindex = AutoTimeMax;
            PlotNext();
         }
      }
   }

   public void PlotNext()
   {
      if (index<PlotBar.Length)
      {
         DoMethodEvent(Plots.S_Plots[PlotBar[index]].Face);
         Text_Plot.text = GetLanguagePlot(PlotBar[index]);
         Text_Name.text = GetLanguageName(PlotBar[index]);
      }else if (index== PlotBar.Length)
      {
         PlotFinEvent();
      }

      index++;
   }

   public void RefreshLanguage()
   {
      try
      {
         Text_Plot.text = GetLanguagePlot(PlotBar[index-1]);
         Text_Name.text = GetLanguageName(PlotBar[index-1]);
      }
      catch (IndexOutOfRangeException e)
      {
         Text_Plot.text = GetLanguagePlot(PlotBar[PlotBar.Length-1]);
         Text_Name.text = GetLanguageName(PlotBar[PlotBar.Length-1]);
      }
   
   }

   /// <summary>
   /// 根据语言获得剧情
   /// </summary>
   /// <param name="index"></param>
   /// <returns></returns>
   public string GetLanguagePlot(int index)
   {
    //  Debug.LogError(index+Plots.S_Plots[index].CN+Plots.S_Plots[index].NameCN);
      switch (Center.Language)
      {
         case "CN":
            return Plots.S_Plots[index].CN;
         case "EN":
            return Plots.S_Plots[index].EN;
         case "JP":
            return Plots.S_Plots[index].JP;
      }
Debug.LogError("语言??");
      return null;
   }
   /// <summary>
   /// 根据语言获得剧情
   /// </summary>
   /// <param name="index"></param>
   /// <returns></returns>
   public string GetLanguageName(int index)
   {
      switch (Center.Language)
      {
         case "CN":
            return Plots.S_Plots[index].NameCN;
         case "EN":
            return Plots.S_Plots[index].NameEN;
         case "JP":
            return Plots.S_Plots[index].NameJP;
      }
      Debug.LogError("语言??");
      return null;
   }
   
   
   /// <summary>
   /// 设置对话列表
   /// </summary>
   /// <param name="t"></param>
   public void SetPlotBar(int[] t,Action FinEvent)
   {
      PlotBar = t;
      PlotFinEvent = FinEvent;
   }

   #region 分支
   public void MakeChoice(int [] choices)
   {
      CloseAllButtons();
      for (int i = 0; i<choices.Length; i++)
      {
         int i1 = i;

         ChoiceButton[i1].gameObject.SetActive(true);
         ChoiceButton[i1].transform.Find("Text").GetComponent<Text>().text = GetLanguagePlot(choices[i1]+1);
         ChoiceButton[i1].onClick.AddListener(() =>
         {
            index = 0;
            Debug.LogError("执行事件BTN"+(choices[i1]+2));
            ExecuteMethodByName("BTN"+(choices[i1]+2));
            CloseAllButtons();
            PlotNext();
         });
      }
   }

   public void CloseAllButtons()
   {
      foreach (var VARIABLE in ChoiceButton)
      {
         VARIABLE.onClick.RemoveAllListeners();
         VARIABLE.gameObject.SetActive(false);
      }
   }

   public void BTN9()
   {
      SetPlotBar(new int[]{10,11,12,13},JumpToGameLevel);
   }
   public void BTN10()
   {
      SetPlotBar(new int[]{14,15,16},JumpToGameLevel);
   }
   public void BTN18()
   {
      SetPlotBar(new int[]{0,1,2,3,4,5,6,7},() => MakeChoice(new int[] { 7, 8 ,16}));
   }
   #endregion

   public void JumpToGameLevel()
   {
      Debug.LogError("将跳转场景");
   }
   public void ExecuteMethodByName(string methodName)
   {
      // 使用反射获取类的类型
      Type type = this.GetType();

      // 使用反射获取方法信息
      MethodInfo methodInfo = type.GetMethod(methodName);

      if (methodInfo != null)
      {
         // 调用匹配的方法
         methodInfo.Invoke(this, null);
      }
      else
      {
         Console.WriteLine("Method not found: " + methodName);
      }
   }

   public string[] CutMethod(string input)
   {
      return input.Split('+');
   }

   public void DoMethodEvent(string input)
   {
      Debug.LogError(input);
      foreach (var VARIABLE in CutMethod(input))
      {
         if (!VARIABLE.Contains("("))
         {
            ExecuteMethodByName(VARIABLE);
         }
         else if (VARIABLE.Contains("JOIN_"))
         {
            Match match = Regex.Match(VARIABLE, @"\(([^)]*)\)");
            if (match.Success)
            {
               // 获取括号内的内容，并使用逗号分割
               string[] parts = match.Groups[1].Value.Split(',');

               if (parts.Length == 4)
               {
                  string stringValue = parts[0];
                  int intValue1, intValue2;
                  if (int.TryParse(parts[1], out intValue1) && int.TryParse(parts[2], out intValue2))
                  {
                     string stringValue2 = parts[3];

                     GameObject go = Instantiate(Resources.Load<GameObject>($"Live2D/{stringValue}"), Live2DFolider.transform);
                     go.transform.position = new Vector3(-999, -999, 2);
                     go.name = go.name.Replace("(Clone)", "");
                     Vector3 worldCoordinate= Vector3.down;
                     ;
                     switch (stringValue2)
                     {
                        case "Left":

                           worldCoordinate =Camera.main.ScreenToWorldPoint( new Vector3(intValue1-DomoveOffeset, intValue2, 2));
                           Debug.LogError(worldCoordinate);
                           worldCoordinate.z = 2;
                           go.transform.position = worldCoordinate;
                           worldCoordinate = Camera.main.ScreenToWorldPoint(new Vector3(intValue1, intValue2, 0));
                           worldCoordinate.z = 0;
                           go.transform.DOMove(worldCoordinate,DomoveTime);


                         
                           break;
                        case "Right":
                           worldCoordinate =Camera.main.ScreenToWorldPoint( new Vector3(intValue1+DomoveOffeset, intValue2, 2));
                           Debug.LogError(worldCoordinate);
                           worldCoordinate.z = 2;
                           go.transform.position = worldCoordinate;
                           worldCoordinate = Camera.main.ScreenToWorldPoint(new Vector3(intValue1, intValue2, 0));
                           worldCoordinate.z = 0;
                           go.transform.DOMove(worldCoordinate,DomoveTime);

                           break;
                     }

                  }
                  else
                  {
                     Debug.LogError("Failed to parse integers from the input.");
                  }
               }
               else
               {
                  Debug.LogError("Input does not contain 4 comma-separated values.");
               }
            }
            else
            {
               Debug.LogError("Input does not match the expected format.");
            }
         }
         else if (VARIABLE.Contains("SETA_"))
         {
            Match match = Regex.Match(VARIABLE, @"\(([^)]*)\)");
            if (match.Success)
            {
               // 获取括号内的内容，并使用逗号分割
               string[] parts = match.Groups[1].Value.Split(',');

               if (parts.Length == 3)
               {
                  string stringValue = parts[0];
                  int intValue1, intValue2;
                  if (int.TryParse(parts[1], out intValue1) && int.TryParse(parts[2], out intValue2))
                  {
                     GameObject go = Live2DFolider.transform.Find(parts[0]).gameObject;
                     SetLive2DAlpha(go,intValue1,intValue2);
                  }
                  else
                  {
                     Debug.LogError("Failed to parse integers from the input.");
                  }
               }
               else
               {
                  Debug.LogError("Input does not contain 3 comma-separated values."+VARIABLE+$"length={parts.Length}");
               }
            }
            else
            {
               Debug.LogError("Input does not match the expected format.");
            }
         }
         else if (VARIABLE.Contains("FACE"))
         {
            Match match = Regex.Match(VARIABLE, @"\(([^)]*)\)");
            if (match.Success)
            {
               // 获取括号内的内容，并使用逗号分割
               string[] parts = match.Groups[1].Value.Split(',');

               if (parts.Length == 2)
               {
                  string stringValue = parts[0];
                  string stringValue2 = parts[1];
                  GameObject go = Live2DFolider.transform.Find(parts[0]).gameObject;
                  SetFace(go,stringValue2);
               }
               else
               {
                  Debug.LogError("Input does not contain 4 comma-separated values.");
               }
            }
            else
            {
               Debug.LogError("Input does not match the expected format.");
            }
         }
         else if (VARIABLE.Contains("LEAV_"))
         {
            Match match = Regex.Match(VARIABLE, @"\(([^)]*)\)");
            if (match.Success)
            {
               // 获取括号内的内容，并使用逗号分割
               string[] parts = match.Groups[1].Value.Split(',');

               if (parts.Length == 2)
               {
                  string stringValue = parts[0];
                  GameObject go = Live2DFolider.transform.Find(parts[0]).gameObject;
                  Vector3 worldCoordinate;
                  StartCoroutine(des(go));
                        break;
                        IEnumerator des(GameObject go)
                        {
                           SetLive2DAlpha(go,
                              (int)(go.transform.Find("Drawables").GetComponentsInChildren<CubismRenderer>()[0]
                                 .GetComponent<CubismRenderer>().Color.a)*100, 0);
                           Debug.LogError($"Des{go.name}");
                           yield return new WaitForSeconds(0.3f);
                           Destroy(go);
                        }
                  
               }
               else
               {
                  Debug.LogError("Input does not contain 4 comma-separated values.");
               }
            }
            else
            {
               Debug.LogError("Input does not match the expected format.");
            }
         }
      }
   }

   public void SetLive2DAlpha(GameObject target, int begin,int end)
   {
      StartCoroutine(AlphaChangerCoroutine(target, begin / 100.0f, end / 100.0f));
   }

   private IEnumerator AlphaChangerCoroutine(GameObject target, float begin, float end)
   {
      foreach (var renderer in target.transform.Find("Drawables").GetComponentsInChildren<CubismRenderer>())
      {
         Color currentColor = renderer.Color;
         currentColor.a = begin;
         Debug.LogError(currentColor.a);
         renderer.Color = currentColor;
      }
      float duration = 0.1f;
      int numSteps = 10;
      float stepTime = duration / numSteps;

      for (int step = 0; step <= numSteps; step++)
      {
         float a = begin;
         if (end>begin)
         {
            a += (end - begin) / numSteps * step;
         }
         else
         {
            a -= (begin - end) / numSteps * step;
         }
         foreach (var renderer in target.transform.Find("Drawables").GetComponentsInChildren<CubismRenderer>())
         {
//            Debug.LogError(renderer.name);
            Color currentColor = renderer.Color;
            currentColor.a = a;
            Debug.LogError(currentColor.a);
            renderer.Color = currentColor;
         }
         yield return new WaitForSeconds(stepTime);
      }
   }
   public void SetFace(GameObject go, string Animatorname)
   {
      go.GetComponent<Animator>().Play(Animatorname);
   }
   
   
}

最终效果

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1141288.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Linux】部署单机OA项目及搭建spa前后端分离项目

【Linux】部署单机OA项目及搭建spa前后端分离项目

一&#xff0c;部署oa项目 在虚拟机中&#xff0c;将项目打包成war文件放置到tomcat根目录下的webapps文件目录下 再在主机数据库中连接数据库&#xff0c;并定义数据库名导入相关的表 继续进入tomcat目录下双击点击startup.bat&#xff0c;启动oa项目 主机访问OA项目 如果登入…
阅读更多...
MySQL之事务、存储引擎、索引

MySQL之事务、存储引擎、索引

文章目录 前言一、事务1.概念2.操作&#xff08;1&#xff09;开启事务&#xff08;2&#xff09;提交事务&#xff08;3&#xff09;回滚事务 3.四大特性ACID&#xff08;1&#xff09;原子性&#xff08;Atomicity&#xff09;&#xff08;2&#xff09;一致性&#xff08;Co…
阅读更多...
Web APIs——焦点事件以及小米搜索框

Web APIs——焦点事件以及小米搜索框

一、事件类型 二、焦点事件 <body><input type"text"><script>const input document.querySelector(input)input.addEventListener(focus,function(){console.log(有焦点触发)})input.addEventListener(blur,function(){console.log(失去焦点触…
阅读更多...
H5新Api | requestIdleCallback - requestAnimationFram

H5新Api | requestIdleCallback - requestAnimationFram

文章目录 浏览器渲染机制事件循环机制宏队列与微队列浏览器中事件循环流程 requestAnimationFrame(rAF)requestAnimationFrame API requestIdleCallbackrequestIdleCallback API任务拆分requestIdleCallback的使用场景 浏览器渲染机制 每一轮 Event Loop 都会伴随着渲染吗&…
阅读更多...
力扣：142. 环形链表 II（Python3）

力扣：142. 环形链表 II（Python3）

题目&#xff1a; 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评…
阅读更多...
命令行参数、环境变量

命令行参数、环境变量

我们在使用C语言的时候&#xff0c;经常的写法是int main(){//函数体}。 而且我们也知道它也只是一个函数&#xff0c;当一个进程启动的时候&#xff0c;会有专门的函数来调用这个函数。 那他有没有函数参数呢&#xff1f;其实也是有的&#xff0c;我们今天&#xff0c;就来认识…
阅读更多...
常用的网络攻击手段

常用的网络攻击手段

前言&#xff1a;本文旨在介绍目前常用的网络攻击手段&#xff0c;分享交流技术经验 目前常用的网络攻击手段 社会工程学攻击物理攻击暴力攻击利用Unicode漏洞攻击利用缓冲区溢出漏洞进行攻击等技术 社会工程学攻击 社会工程学 根据百度百科定义&#xff1a; 社会工…
阅读更多...
2023/10/27 JAVA学习

2023/10/27 JAVA学习

tab键可以对文件名进行补全 想切到其他盘的某个文件,必须先使用切盘命令 在当前文件目录输入cmd,可直接打开命令行窗口,并且处于当前文件目录 运行java文件,只用文件名不需要后缀 记得勾选文件扩展名 直接这样执行不会出现class文件,因为在底层临时生成了一个,不会长久的出现
阅读更多...
NX二次开发后处理中保存tcl变量值到文本

NX二次开发后处理中保存tcl变量值到文本

直接上代码&#xff1a; static bool GetTclValue(UF_MOM_id_t mom_id, char *szName, char *szInfo, std::string &stValue,bool bShowValue /* false*/) {UF_MOM_ask_string(mom_id, szName, (const char **)&szInfo);if (szInfo){stValue szInfo;if (bShowValue){…
阅读更多...
ArrayList的线程安全类CopyOnWriteArrayList

ArrayList的线程安全类CopyOnWriteArrayList

目录 一、CopyOnWriteArrayList简介二、CopyOnWriteArrayList的优缺点1、优点2、缺点 三、CopyOnWriteArrayList使用场景1、数据库缓存2、消息队列3、数据统计和分析 四、使用CopyOnWriteArrayList时需要注意哪些问题&#xff1f;1、内存占用问题2、数据一致性问题3、线程安全4…
阅读更多...
Milvus 入门教程

Milvus 入门教程

文章目录 下载docker-compose配置文件安装 docker安装docker-compose直接下载release版本手动安装使用pip 命令自动安装 通过 docker-compose 启动容器连接 Milvus停止 milvus删除milvus的数据 下载docker-compose配置文件 先安装wget命令 yum install wget下载配置文件&…
阅读更多...
C++之C++11字符串字面量后缀总结(二百四十八)

C++之C++11字符串字面量后缀总结(二百四十八)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 人生格言&#xff1a; 人生…
阅读更多...
如何高效自学（黑客技术）方法——网络安全

如何高效自学（黑客技术）方法——网络安全

如果你想自学网络安全&#xff0c;首先你必须了解什么是网络安全&#xff01;&#xff0c;什么是黑客&#xff01;&#xff01; 1.无论网络、Web、移动、桌面、云等哪个领域&#xff0c;都有攻与防两面性&#xff0c;例如 Web 安全技术&#xff0c;既有 Web 渗透2.也有 Web 防…
阅读更多...
2023版 STM32实战12 IIC总线读写AT24C02

2023版 STM32实战12 IIC总线读写AT24C02

IIC简述 一个多主从的串行总线&#xff0c;又叫I2C&#xff0c;是由飞利浦公司发明的通讯总线 IIC特点 -1- 串行(逐bit传输) -2- 同步(共用时钟线) -3- 半双工(收发不同进行) -4- 总线上的任何设备都可以是主机 开发使用习惯和理解 -1- 通过地址寻址 -2- 数据线的…
阅读更多...
Linux权限及Xshell运行原理

Linux权限及Xshell运行原理

目录 1.Linux中的用户 1.1 用户分类 1.2 用户切换 2.权限的概念 2.1 权限概念以及表示 2.2 文件属性以及类型 2.2.1 文件属性 2.2.2 文件类型 2.3 Linux下的角色 3.权限的修改 3.1 chmod 3.2 chown 3.3 chgrp 4.目录权限 5.权限掩码 5.1 默认权限 5.2 起始权限…
阅读更多...
省时省力！掌握简单快捷的关机命令，轻松实现电脑的自由开关机

省时省力！掌握简单快捷的关机命令，轻松实现电脑的自由开关机

本文介绍了为电脑设置特定的自动关机时间的四种方法。我们还包括如何停止计划关机的信息。 如何用命令提示符安排计算机关机 按照以下步骤使用命令提示符进行一次性关闭。 1、在Windows搜索框中，键入CMD。 2、点击Enter。 3、在命令提示符窗口中，键入shutdown -s -t 和所…
阅读更多...
matlab simulink 四旋翼跟拍无人机仿真

matlab simulink 四旋翼跟拍无人机仿真

1、内容简介 略 7-可以交流、咨询、答疑 2、内容说明 四旋翼跟拍无人机仿真 四旋翼、无人机 需求分析 背景介绍 无人飞行机器人&#xff0c;是无人驾驶且具有一定智能的空中飞行器。这是一种融合了计算机技术、人工智能技术、传感器技术、自动控制技术、新型材料技术、导航…
阅读更多...
基于机器视觉的车道线检测 计算机竞赛

基于机器视觉的车道线检测 计算机竞赛

文章目录 1 前言2 先上成果3 车道线4 问题抽象(建立模型)5 帧掩码(Frame Mask)6 车道检测的图像预处理7 图像阈值化8 霍夫线变换9 实现车道检测9.1 帧掩码创建9.2 图像预处理9.2.1 图像阈值化9.2.2 霍夫线变换 最后 1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分…
阅读更多...
HCL模拟器选路实验案例

HCL模拟器选路实验案例

此选路题目选自职业院校技能竞赛中的一道题比较考验思路&#xff0c;适合于参加新华三杯大赛以及网络专业的同学&#xff0c;当做练习题目进行解题​​​​​​​ 题目 1.S1、S2、R1、R2运行ospf进程100&#xff0c;区域0&#xff0c;R1、R2、R3、R4、R5运行ospf进程200&#…
阅读更多...
Linux进阶之旅：从零开始，探索基本指令的神秘力量！

Linux进阶之旅：从零开始，探索基本指令的神秘力量！

&#x1f389;&#x1f389;欢迎来到我的CSDN主页&#xff01;&#x1f389;&#x1f389; &#x1f3c5;我是尘缘&#xff0c;一个在CSDN分享笔记的博主。&#x1f4da;&#x1f4da; &#x1f449;点击这里&#xff0c;就可以查看我的主页啦&#xff01;&#x1f447;&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023