C# 使用NOPI操作Excel及与datatable相关操作

最新推荐文章于 2024-04-17 10:13:12 发布
最新推荐文章于 2024-04-17 10:13:12 发布
阅读量830 收藏 4
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31257197/article/details/79216530
版权
本文介绍了一种利用NOPI库实现Excel文件与DataTable互相转换的方法，并提供了将DataGridView中的数据导出为Excel文件的示例代码。此外，还展示了如何自定义单元格样式和数据格式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

NOPI使用方式

注意事项:读取数据时要判断celltype

创建指定格式的excel时要 先把所需要的font创建好,cellstyle创建好,然后创建格子,给各个格子设定风格

假设所有格子内容都是字符串,第一行为数据列,下面则是datatable与excel互转的方法

  public static DataTable ExcelToTable(string fileName)
        {
            ISheet sheet = null;
            IWorkbook workbook = null;
            DataTable table = new DataTable();
            using (FileStream fs = File.OpenRead(fileName))
            {
                if (fileName.Contains(".xlsx"))
                {
                    workbook = new XSSFWorkbook(fs);
                }
                else if (fileName.Contains(".xls"))
                {
                    workbook = new HSSFWorkbook(fs);
                }
                else
                {
                    throw new Exception("不是有效的Excel类型");
                }
            }
            sheet = workbook.GetSheetAt(0);
            IRow firstRow = sheet.GetRow(0);
            int cellCount = firstRow.LastCellNum;//列的总数
            for (int i = 0; i < cellCount; i++)
            {
                ICell cell = firstRow.GetCell(i);
                if (cell != null)
                {
                    string cellValue = cell.StringCellValue;
                    DataColumn column = new DataColumn(cellValue);
                    table.Columns.Add(column);
                }
            }
            int rowCount = sheet.LastRowNum;
            for (int i = 1; i < rowCount; i++)
            {
                IRow row = sheet.GetRow(i);
                if (row == null)
                    continue;
                DataRow dataRow = table.NewRow();
                for (int j = 0; j < cellCount; j++)
                {
                    string value = row.GetCell(j) == null ? "" : row.GetCell(j).ToString();
                    dataRow[j] = value;
                }
                table.Rows.Add(dataRow);
            }
            return table;
        }

        /// <summary>
        /// 表中内容均为string
        /// </summary>                
        public static void ExportToXls(string fileName, DataTable dataTable)
        {
            HSSFWorkbook workBook = new HSSFWorkbook();
            ISheet sheet = workBook.CreateSheet();
            int i = 1;
            int jL = dataTable.Columns.Count;

            IRow r0 = sheet.CreateRow(0);//列头            
            int jj = 0;
            foreach (DataColumn item in dataTable.Columns)
            {
                ICell cell = r0.CreateCell(jj);
                cell.CellStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
                cell.SetCellValue(item.ColumnName);
                jj++;
            }

            foreach (DataRow item in dataTable.Rows)
            {
                IRow row = sheet.CreateRow(i);
                for (int j = 0; j < jL; j++)
                {
                    ICell cell = row.CreateCell(j);
                    cell.SetCellValue(item[j].ToString());
                }
                i++;
            }

            using (FileStream fs = File.OpenWrite(fileName))
            {
                workBook.Write(fs);
            }
        }
public static void DataGridViewToExcel(DataGridView dgv, string defaultName = "")
        {
            #region
            string fileNameString = defaultName;
            if (string.IsNullOrEmpty(fileNameString))
            {
                SaveFileDialog dlg = new SaveFileDialog();
                dlg.FileName = defaultName;

                dlg.DefaultExt = "xls";
                dlg.Filter = "Excel 2003 文件(*.xls)|*.xls|Excel 2007 文件(*.xlsx)|*.xlsx";

                if (dlg.ShowDialog() == DialogResult.Cancel) return;
                fileNameString = dlg.FileName;
            }
            if (string.IsNullOrEmpty(fileNameString)) return;

            string ext = ".xls";
            if (fileNameString.ToLower().EndsWith(".xlsx")) ext = ".xlsx";

            int rowscount = dgv.Rows.Count;
            int colscount = dgv.Columns.Count;

            if (rowscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (colscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (ext.ToLower() == ".xls" && rowscount > 65536)
            {
                MessageBox.Show("数据记录数太多(最多不能超过65536条)，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (ext.ToLower() == ".xlsx" && rowscount > 1048576)
            {
                MessageBox.Show("数据记录数太多(最多不能超过1048576条)，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if ((ext.ToLower() == ".xls" && colscount > 255) || (ext.ToLower() == ".xlsx" && colscount > 16384))
            {
                MessageBox.Show("数据记录行数太多，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            FileInfo file = new FileInfo(fileNameString);
            if (file.Exists)
            {
                try
                {
                    file.Delete();
                }
                catch (Exception error)
                {
                    MessageBox.Show(error.Message, "删除失败 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
            }
            #endregion

            IWorkbook objWorkbook = null;
            ISheet objsheet = null;
            try
            {
                if (ext.ToLower() == ".xls")
                {
                    objWorkbook = new HSSFWorkbook();
                }
                else
                {
                    objWorkbook = new XSSFWorkbook();
                }

                objsheet = objWorkbook.CreateSheet("sheet1");

                IRow rowHeader = objsheet.CreateRow(0);

                ICellStyle style = objWorkbook.CreateCellStyle();
                style.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;

                int displayColumnsCount = 0;
                for (int i = 0; i <= dgv.ColumnCount - 1; i++)
                {
                    if (dgv.Columns[i].Visible == true)
                    {
                        rowHeader.CreateCell(displayColumnsCount).SetCellValue(dgv.Columns[i].HeaderText.Trim());
                        ICell cellHeader = rowHeader.GetCell(displayColumnsCount);
                        cellHeader.CellStyle = style;
                        objsheet.SetColumnWidth(displayColumnsCount, 20 * 256);   //设置列宽
                        displayColumnsCount++;
                    }
                }

                displayColumnsCount = 1;
                int idx = 1;
                for (int row = 0; row < rowscount; row++)
                {
                    if (dgv.Rows[row].Cells[0].FormattedValue.ToString() != "")
                    {
                        try
                        {
                            IRow newRow = objsheet.CreateRow(idx);
                            int colIndex = 0;   //真实的列
                            for (int col = 0; col < colscount; col++)
                            {
                                if (dgv.Columns[col].Visible == false)
                                    continue;
                                ICell cell = newRow.CreateCell(colIndex);
                                ++colIndex;
                                cell.CellStyle = style;
                                //cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue);
                                switch (dgv.Columns[col].ValueType.Name)
                                {
                                    case "Boolean":
                                        cell.SetCellValue((bool)dgv.Rows[row].Cells[col].FormattedValue);
                                        break;
                                    case "Double":
                                        if (dgv.Rows[row].Cells[col].FormattedValue.ToString() == "-")
                                        {
                                            cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        }
                                        else if (string.IsNullOrEmpty(dgv.Rows[row].Cells[col].FormattedValue.ToString()))
                                        {
                                            cell.SetCellValue("-");
                                        }
                                        else
                                        {
                                            cell.SetCellValue(double.Parse(dgv.Rows[row].Cells[col].FormattedValue.ToString()));
                                        }
                                        break;
                                    case "DateTime":
                                        //cell.SetCellValue(DateTime.Parse(dgv.Rows[row].Cells[col].FormattedValue.ToString()));
                                        if (dgv.Rows[row].Cells[col].FormattedValue.ToString() == "-")
                                        {
                                            cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        }
                                        else if (string.IsNullOrEmpty(dgv.Rows[row].Cells[col].FormattedValue.ToString()))
                                        {
                                            cell.SetCellValue("-");
                                        }
                                        else
                                        {
                                            cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        }
                                        break;
                                    case "String":
                                        if (dgv.Rows[row].Cells[col].FormattedValue.ToString() == "-")
                                        {
                                            cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        }
                                        else if (string.IsNullOrEmpty(dgv.Rows[row].Cells[col].FormattedValue.ToString()))
                                        {
                                            cell.SetCellValue("-");
                                        }
                                        else
                                        {
                                            cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        }
                                        break;
                                    default:
                                        cell.SetCellValue(dgv.Rows[row].Cells[col].FormattedValue.ToString());
                                        break;
                                }
                            }
                            ++idx;
                        }
                        catch (Exception error1)
                        {
                            MessageBox.Show(error1.Message, "警告 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                            return;
                        }
                    }
                }

                using (FileStream stream = new FileStream(fileNameString, FileMode.Create, FileAccess.ReadWrite))
                {
                    objWorkbook.Write(stream);
                }

            }
            catch (Exception error)
            {
                MessageBox.Show(error.Message, "警告 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            finally
            {
                objsheet = null;                
                objWorkbook = null;
            }

            if (string.IsNullOrEmpty(defaultName))
            {
                if (MessageBox.Show("数据成功导出到\"" + fileNameString + "\"，是否现在打开？", "导出",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    System.Diagnostics.Process.Start(fileNameString);
                }
            }
        }

如果要操作excel,最好写个excelHelper类进行处理

    public static void ExportDataGeneral(DataTable data, string defaultName = "")
        {    
            #region 通用处理
            string fileNameString = defaultName;
            if (string.IsNullOrEmpty(fileNameString))
            {
                SaveFileDialog dlg = new SaveFileDialog();
                dlg.FileName = defaultName;

                dlg.DefaultExt = "xls";
                dlg.Filter = "Excel 2003 文件(*.xls)|*.xls|Excel 2007 文件(*.xlsx)|*.xlsx";

                if (dlg.ShowDialog() == DialogResult.Cancel) return;
                fileNameString = dlg.FileName;
            }
            if (string.IsNullOrEmpty(fileNameString)) return;

            string ext = ".xls";
            if (fileNameString.ToLower().EndsWith(".xlsx")) ext = ".xlsx";

            int rowscount = data.Rows.Count;
            int colscount = data.Columns.Count;

            if (rowscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (colscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (ext.ToLower() == ".xls" && rowscount > 65536)
            {
                MessageBox.Show("数据记录数太多(最多不能超过65536条)，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (ext.ToLower() == ".xlsx" && rowscount > 1048576)
            {
                MessageBox.Show("数据记录数太多(最多不能超过1048576条)，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if ((ext.ToLower() == ".xls" && colscount > 255) || (ext.ToLower() == ".xlsx" && colscount > 16384))
            {
                MessageBox.Show("数据记录行数太多，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            FileInfo file = new FileInfo(fileNameString);
            if (file.Exists)
            {
                try
                {
                    file.Delete();
                }
                catch (Exception error)
                {
                    MessageBox.Show(error.Message, "删除失败 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
            }
            #endregion

            IWorkbook objWorkbook = null;
            ISheet objsheet = null;
            try
            {
                if (ext.ToLower() == ".xls")
                {
                    objWorkbook = new HSSFWorkbook();
                }
                else
                {
                    objWorkbook = new XSSFWorkbook();
                }
                objsheet = objWorkbook.CreateSheet("用户数据");

                ICellStyle style = objWorkbook.CreateCellStyle();
                style.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
                #region   数据头
                IRow rowHeader = objsheet.CreateRow(0);
                int displayColumnsCount = 0;
                for (int i = 0; i < data.Columns.Count; i++)
                {
                    string caption = data.Columns[i].Caption.Trim();
                    if (data.Columns[i].ExtendedProperties.ContainsKey("DisplayName"))
                    {
                        caption = data.Columns[i].ExtendedProperties["DisplayName"].ToString();
                    }
                    rowHeader.CreateCell(displayColumnsCount).SetCellValue(caption);
                    ICell cellHeader = rowHeader.GetCell(displayColumnsCount);
                    cellHeader.CellStyle = style;
                    objsheet.SetColumnWidth(displayColumnsCount, 20 * 256);
                    displayColumnsCount++;
                }
                #endregion

                #region 定义格式
                Dictionary<string, ICellStyle> dicStyles = new Dictionary<string, ICellStyle>();
                IDataFormat format = objWorkbook.CreateDataFormat();
                ICellStyle cellStyle = objWorkbook.CreateCellStyle();
                cellStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Right;
                cellStyle.DataFormat = format.GetFormat("0.00");
                dicStyles.Add("0.00", cellStyle);

                ICellStyle cellStyle1 = objWorkbook.CreateCellStyle();
                cellStyle1.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Right;
                cellStyle1.DataFormat = format.GetFormat("0");
                dicStyles.Add("0", cellStyle1);

                //自定义0.000                
                ICellStyle cellStyle2 = objWorkbook.CreateCellStyle();
                cellStyle2.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Right;
                cellStyle2.DataFormat = format.GetFormat("0.000");
                dicStyles.Add("0.000", cellStyle);

                //常规
                ICellStyle cellStyle3 = objWorkbook.CreateCellStyle();
                cellStyle3.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Right;
                cellStyle3.DataFormat = format.GetFormat("General");
                dicStyles.Add("General", cellStyle3);

                //文本
                ICellStyle styleG = objWorkbook.CreateCellStyle();
                styleG.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Left;
                styleG.DataFormat = format.GetFormat("@");
                dicStyles.Add("@", styleG);

                //文本
                ICellStyle styleDate = objWorkbook.CreateCellStyle();
                styleDate.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Left;
                styleDate.DataFormat = format.GetFormat("yyyy-mm-dd");
                dicStyles.Add("yyyy-mm-dd", styleDate);
                #endregion

                #region   数据处理
                for (int row = 0; row < data.Rows.Count; row++)
                {
                    IRow contentRow = objsheet.CreateRow(row + 1);
                    int idx = 0;
                    for (int col = 0; col < data.Columns.Count; col++)
                    {
                        //填充数据
                        if (!(data.Rows[row][col] is DBNull) && !string.IsNullOrEmpty(data.Rows[row][col].ToString()))
                        {
                            Type type = data.Columns[col].DataType;
                            if (type == typeof(DateTime))
                            {
                                contentRow.CreateCell(idx).SetCellValue((DateTime)data.Rows[row][col]);
                            }
                            else if (type == typeof(double))
                            {
                                double tmp = 0;
                                if (double.TryParse(data.Rows[row][col].ToString(), out tmp))
                                {
                                    contentRow.CreateCell(idx).SetCellValue(tmp);
                                }

                            }
                            else if (type == typeof(string))
                            {
                                contentRow.CreateCell(idx).SetCellValue(data.Rows[row][col].ToString());
                            }
                            else if (type == typeof(bool))
                            {
                                bool tmp = false;
                                if (bool.TryParse(data.Rows[row][col].ToString(), out tmp))
                                {
                                    contentRow.CreateCell(idx).SetCellValue(tmp ? "是" : "否");
                                }
                            }
                            else
                            {
                                contentRow.CreateCell(idx).SetCellValue(data.Rows[row][col].ToString());
                            }

                            //设置格式
                            if (data.Columns[col].ExtendedProperties.ContainsKey("DisplayFormat"))
                            {
                                string displayFormat = data.Columns[col].ExtendedProperties["DisplayFormat"].ToString();
                                if (!string.IsNullOrEmpty(displayFormat))
                                {
                                    string key = displayFormat;
                                    if (displayFormat.ToUpper().StartsWith("N"))
                                    {
                                        displayFormat = displayFormat.Substring(1);
                                        key = "0";
                                        if (int.Parse(displayFormat) > 0)
                                        {
                                            key += ".";
                                            for (int i = 0; i < int.Parse(displayFormat); i++)
                                            {
                                                key += "0";
                                            }
                                        }
                                    }

                                    if (dicStyles.ContainsKey(key))
                                    {
                                        contentRow.GetCell(idx).CellStyle = dicStyles[key];
                                    }
                                    else
                                    {
                                        ICellStyle styleCustom = objWorkbook.CreateCellStyle();
                                        styleCustom.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Left;
                                        styleCustom.DataFormat = format.GetFormat(key);
                                        dicStyles.Add(key, styleCustom);

                                        contentRow.GetCell(idx).CellStyle = styleCustom;
                                    }
                                }
                                else
                                {
                                    if (type == typeof(DateTime))
                                    {
                                        contentRow.GetCell(idx).CellStyle = styleDate;
                                    }
                                    else if (type == typeof(double))
                                    {
                                        contentRow.GetCell(idx).CellStyle = cellStyle;
                                    }
                                    else if (type == typeof(string))
                                    {
                                        contentRow.GetCell(idx).CellStyle = styleG;
                                    }
                                    else
                                    {
                                        contentRow.GetCell(idx).CellStyle = cellStyle3;
                                    }
                                }
                            }

                        }

                        ++idx;
                    }
                }
                #endregion     

                using (FileStream stream = new FileStream(fileNameString, FileMode.Create, FileAccess.ReadWrite))
                {
                    objWorkbook.Write(stream);
                }                
            }
            catch (Exception error)
            {
            }
            finally
            {
                objsheet = null;
                objWorkbook = null;
            }

            if (string.IsNullOrEmpty(defaultName))
            {
                if (MessageBox.Show("数据成功导出到\"" + fileNameString + "\"，是否现在打开？", "导出",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    System.Diagnostics.Process.Start(fileNameString);
                }
            }

        }
   
 public static List<T> ExcelToList<T>(string fileName) where T:new()
        {
            Type tp = typeof(T);
            List<T> retval = new List<T>();            
            List<string> cols = new List<string>();
            IWorkbook objWorkbook = null;
            ISheet objsheet = null;
            List<PropertyInfo> infos = tp.GetProperties().ToList();
            
            try
            {
                using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite))
                {
                    string ext = ".xls";
                    if (fileName.ToLower().EndsWith(".xlsx")) ext = ".xlsx";
                    if (ext.ToLower() == ".xls")
                    {
                        objWorkbook = new HSSFWorkbook(stream);
                    }
                    else
                    {
                        objWorkbook = new XSSFWorkbook(stream);
                    }
                }
                objsheet = objWorkbook.GetSheetAt(0);
                int rowCount = objsheet.PhysicalNumberOfRows;
                int colsCount = objsheet.GetRow(0).PhysicalNumberOfCells;
                for (int i = 0; i < colsCount; i++)
                {
                    string colName = objsheet.GetRow(0).GetCell(i).StringCellValue.Trim();
                    cols.Add(colName);
                }
                
                for (int row = 1; row < rowCount; row++)
                {
                    IRow hr = objsheet.GetRow(row);
                    if (hr == null) continue;


                    T t = new T();
                    for (int i = 0; i < colsCount; i++)
                    {
                        var pInfo = infos.Find(p => p.Name == cols[i]);
                        if (pInfo != null)
                        {
                            pInfo.SetValue(t, getValue(hr, i).ToString(),null);
                        }                        
                    }
                    retval.Add(t);                    
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                objsheet = null;
                objWorkbook = null;
            }


            return retval;
        }

public static DataTable ExcelToDatable(string fileName)
        {
            DataTable dt = new DataTable();           
            IWorkbook objWorkbook = null;
            ISheet objsheet = null;
            try
            {
                using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite))
                {
                    string ext = ".xls";
                    if (fileName.ToLower().EndsWith(".xlsx")) ext = ".xlsx";
                    if (ext.ToLower() == ".xls")
                    {
                    objWorkbook = new HSSFWorkbook(stream);
                }
                    else
                    {
                        objWorkbook = new XSSFWorkbook(stream);
                    }
                }
                objsheet = objWorkbook.GetSheetAt(0);
                int rowCount = objsheet.PhysicalNumberOfRows;
                int colsCount = objsheet.GetRow(0).PhysicalNumberOfCells;
                for (int i = 0; i < colsCount; i++)
                {
                    string colName = objsheet.GetRow(0).GetCell(i).StringCellValue;
                    dt.Columns.Add(colName);
                }
                DataRow dr;
                for (int row = 1; row < rowCount; row++)
                {
                    IRow hr = objsheet.GetRow(row);
                    if (hr == null) continue;

                    dr = dt.NewRow();
                    for (int i = 0; i < colsCount; i++)
                    {
                        dr[i] = getValue(hr, i);
                    }
                   
                    dt.Rows.Add(dr);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {                
                objsheet = null;
                objWorkbook = null;
            }
            return dt;
        }

        static object getValue(IRow hr, int idx)
        {
            object val = null;
            if (hr.GetCell(idx) == null || hr.GetCell(idx).ToString() == "")
            {
                val = DBNull.Value;
            }
            else
            {
                switch (hr.GetCell(idx).CellType)
                {
                    case CellType.Numeric:
                              //if (idx == 0)
                        //{
                        //    val = (object)hr.GetCell(idx).DateCellValue.ToString("yyyyMMdd");
                        //}
                        //else if (idx == 3)
                        //{
                        //    val = (object)hr.GetCell(idx).NumericCellValue.ToString("P");
                        //}
                        //else
                        //{
                        //    val = (object)hr.GetCell(idx).NumericCellValue;
                        //}
                        val = (object)hr.GetCell(idx).NumericCellValue;
                        break;
                    default:
                        //Formulate
                        hr.GetCell(idx).SetCellType(CellType.String);
                        val = (object)hr.GetCell(idx).StringCellValue;
                        break;
                }
            }
            return val;
        }



自适应背景提取算法与目标跟踪 Matlab 仿真
qq_37934722的博客
05-19 325
常见的背景提取算法包括基于统计学的方法、基于模型的方法和基于深度学习的方法等。本文介绍一种自适应背景提取算法，该算法结合了基于统计学和基于模型的方法，可以在具有复杂动态背景的环境中进行有效的背景提取，并给出了相应的 Matlab 代码实现。本文介绍的算法主要基于两个假设：1）前景像素和背景像素的颜色分布是不同的，并且前景像素的颜色分布可能随时间变化；本文介绍的自适应背景提取算法结合了基于统计学和基于模型的方法，在复杂动态背景下具有很好的性能。基本的自适应背景提取算法，并在每一帧图像中提取出前景区域。
TCP-Drinc:Smart Congestion Control Based on Deep Reinforcement Learning笔记
liu14lang的博客
10-25 1539
introduction 之前大部分算法的assumption：假设丢包仅仅是由于发生buffer overflow了，并且将丢包作为拥塞的标志。 本文是基于sender端的，考虑了如下的features： congestion window difference round trip time (RTT) the minimum RTT over RTT ratio the differenc...
基于人工智能技术的的拥塞控制的基本原理—— PCC Vivace
weixin_46563862的博客
10-03 1398
基于人工智能技术的的拥塞控制的基本原理—— PCC Vivace
A Distributional Perspective on Reinforcement Learning
HAHA的专栏
08-16 2254
传统的强化学习算法例如Q-learning算法学习的是state-action值函数，而这篇文章的核心是学习state-action的概率分布。 具体各简单的例子：例如我们在上班是需要经过6站地铁，每站地铁平均需要5分钟，则上上班需要30分钟。如果每个星期（5天），地铁都会出毛病，则就需要耽误耽搁一个小时。正常情况下上班的时间期望，也就是均值是30分钟，在火车出现故障的情况下，则每天的上班时间期...
ICNP‘2019 Congestion Control for Cross-Datacenter Networks论文阅读笔记
weixin_41820355的博客
10-27 1341
文章目录BackgroundGeminiDiscussion Background 现代的一些大规模在线服务会将他们的信息储存在不同地域的数据中心当中，并且这种分布以及变得越来越流行了。这意味着，有一些流会同时经过数据中心与广域网。(和Annulus中提到的是同一个问题) 实际上这两种网络环境差别是非常大的。 对于广域网，实现高网络利用率是重点，交换机具有深缓冲区，且RTT非常大。 对于DCN，延迟是最关心的指标。而且交换机的缓冲区更浅，RTT更小。 虽然有很多专门为专门为了DCN或者WAN的传输协议，但是
探索 ns3-gym：仿真网络环境的强化学习平台
最新发布
gitblog_00096的博客
04-17 1126
探索 ns3-gym：仿真网络环境的强化学习平台 项目地址:https://gitcode.com/gh_mirrors/ns/ns3-gym 是一个基于著名的网络模拟器 ns-3 构建的强化学习（RL）环境。该项目旨在为网络研究和开发提供一个新的、灵活的工具，使研究人员能够利用 RL 策略优化网络行为和性能。 项目概述 ns3-gym 结合了 ns-3 的精细网络模型和 RL 的智能决策能力，创...
论文阅读笔记——拥塞控制算法PCC
yue2388253的博客
01-16 4791
目录PCC论文阅读笔记TCP为什么这么垃圾传统TCP是怎么干的依赖于**hardwired mapping**会产生什么后果呢？PCC为什么牛逼PCC是怎么干的PCC如何应对噪声？PCC如何取得公平性PCC非常灵活如何部署PCCFAQ最后 PCC论文阅读笔记 本文是关于USDI '15论文《PCC: Re-architecting Congestion Control for Consistent...
SRT协议翻译
sweibd的专栏
04-19 2690
SRT协议 srt是基于UDT传输协议，是用户级别的协议，其保留UDT的核心思想和机制，但是做了多项改进，包括控制报文的修改，针对直播流改进了流控，改进了拥塞算法，报文加密算法。本文介绍srt协议本身。更多的相关实现在：https://github.com/Haivision/srt 简介 srt传输协议为不可靠网络提供安全，可靠的数据传输，如因特网。任何数据都可以在srt协议上传输，特别是对音视...
论文阅读笔记——拥塞控制算法PCC Vivace
yue2388253的博客
01-28 4836
目录PCC Vivace 阅读笔记PCC和BBR都是垃圾！PCC Vivace vs. PCC AllegroAllegro 为什么垃圾？Vivace 为什么比较牛逼？小结Vivace 的目标函数框架小结Vivace如何与传统TCP进行交互？总结 PCC Vivace 阅读笔记 本文是关于NSDI '18论文《PCC Vivace: Online-Learning Congestion Contr...
清华AIOps案例分享|强化学习，降低网络传输延时
weixin_52705010的博客
04-19 1496
本文介绍清华大学聂晓辉等作者发表在JSAC 2019, Artificial Intelligence and Machine Learning for Networking and Communications期刊的论文《Dynamic TCP Initial Windows and CongestionControl Schemes through Reinforcement Learning》
PCC-RL:PCC的强化学习资源
05-07
PCC-RL 增强针对性能导向的拥塞控制项目的学习资源。 概述 此仓库包含训练PCC项目中使用的强化学习模型所需的体育馆环境，以及在github.com/PCCProject/PCC-Uspace上的PCC UDT代码库中运行RL模型所需的Python模块。 训练 仅运行培训，请转到./src/gym/，为stable_solve.py安装所有缺少的要求，然后运行该脚本。 默认情况下，这应该复制ICML 2019的《关于互联网拥塞控制的强化学习观点》中介绍的模型。 测试模型 要测试现实世界中的模型（即，将实际的数据包发送到Linux内核并发送到真实的或仿真的网络中），请从github.com/PCCProject/PCC-Uspace下载并安装PCC UDT代码。 请遵循该存储库中的说明，以将拥塞控制算法与Python模块一起使用，并参阅./src/gym/online/README.m
拥塞控制算法18年sigcomm
04-01
一片关于拥塞控制的论文，可以看看，个人感觉还是不错的
【调研】DRL优化网络通信领域顶会及期刊
bajiaoyu517的博客
03-29 1717
一、通信类顶会及期刊 会议 A类 IEEE International Conference on Communications/ ICC/ IEEE通信国际会议 IEEEGlobal Telecommunications Conference/ Globecom/ IEEE全球电信会议 B类 International Conference on Telecommunications/　ICT/ 电信国际会议 IEEE Wireless Communicat
拥塞控制算法的评价标准
u010643777的专栏
06-12 2304
 一个理想的拥塞控制曲线，应该是什么样子呢？如下图：  怎么样才能达到这个结果呢？目前有好几篇文章，都给出了类似的图例。列出reference供参考。  未完待续。 Reference: [1] Data Center TCP [2] MDTCP: Towards a Practical Multipath Transport Protocol for Telco Cloud Datacente...
paper: Congestion Control: A Renaissance via Wenting Wei, Huaxi Gu, and Baochun Li
Hesy_H的博客
03-12 686
是网络拥塞控制方面的一个review 作者最后总结重点强调了几点趋势： Recent works on this topic have seemingly converged on the use of either offline or online learning algorithms to replace heuristics designed for specific types of...
OnRL: 基于在线强化学习的移动视频传输优化
淘系技术
10-14 4858
从2019年开始，淘系技术部内容社交互动团队和北京邮电大学周安福教授一起着手研究更好的基于机器学习的智能拥塞控制算法。在实验室环境完成原型验证后在淘宝直播的生产环境做实际效果对比，从实际...
拥塞控制(详解)
热门推荐
qq_48508278的博客
01-23 2万+
一：TCP的拥塞控制 1:是什么 (1):是什么(拥塞现象) 网络的 吞吐量 与 通信子网 负荷(即通信子网中正在传输的分组数)有着密切的关系。当 通信子网 负荷比较小时,网络的 吞吐量 (分组数/秒)随网络负荷(每个 节点 中分组的平均数)的增加而线性增加。当网络负荷增加到某一值后,若 网络吞吐量 反而下降，则表征网络中出现了拥塞现象。在一个出现拥塞现象的网络中，到达某个 节点 的分组将会遇到无缓冲区可用的情况，从而使这些分组不得不由前一节点重传,或者需要由源节点或源 端系统 重传。当拥塞比较严重时， 通
常用的机器学习算法学习
mykeylock的博客
11-08 394
1、GBDT（Gradient Boosting Decision Tree） 2、FM（主要用于处理数据稀疏的情况），针对两两特征，增加一个系数W用于提取特征间的关系， 而后用一个小矩阵V，乘以V转置来代替W矩阵。 3、决策树与回归树： 决策树是判断yes或no，每一步选择特征时用的是（熵增益）或者（Gini系数）的方法 回归树则用于拟合，结果需要给出一个特定的数值，每一步选择特征时用
流媒体学习之路(WebRTC)——Pacer与GCC（5）
qw225967的博客
01-02 2119
Pacer（Packet Pacing）的作用是在传输数据时能平滑的发送出去，减少对网络冲击和抖动的产生，提高通信质量。在一次数据传输中，如果所有包几乎同时发送，网络就可能会遭遇到冲击，这就可能导致网络拥塞，数据包丢失等问题。为了避免这样的问题，需要通过一个定时器均匀分散发送数据包。特别是在音视频传输中，PACER更是非常重要的一部分。因为音视频的传输对于网络的稳定性和实时性要求非常高，任何形式的网络抖动或者丢包都会造成音视频的卡顿，延迟等问题。
解释一下congestion control中的exponential and then linear
05-30
Exponential and then linear是一种拥塞控制算法，通常用于TCP协议中。该算法的基本思想是，在初始阶段，每个TCP连接都有一个较小的拥塞窗口大小，然后该窗口大小以指数级别增加，直到网络拥塞。一旦网络开始出现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值