TIN体积

已于 2025-03-22 16:59:28 修改
阅读量154 收藏
点赞数 1
文章标签： windows
于 2025-03-22 16:19:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xin__xiao/article/details/146441979
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.IO;
using System.Drawing;

namespace TIN_321
{
    public partial class Form1 : Form
    {
        string[] all_lines;
        List<Mypoints> allPoints = new List<Mypoints>(); 
        string jzH;

        // 初始三角网构建
        List<Triangle> T1 = new List<Triangle>(); 
        List<Triangle> T2 = new List<Triangle>(); 
        List<Edge> S = new List<Edge>(); 

        public Form1()
        {
            InitializeComponent();
        }
        private bool isDragging = false;
        private Point mouseDownLocation; 

        private void 打开文件ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog op = new OpenFileDialog();
            if (op.ShowDialog() == DialogResult.OK)
            {
                all_lines = File.ReadAllLines(op.FileName);
            }
            else
            {
                return;
            }

            try
            {
                jzH = all_lines[0].Split(',')[1];
                for (int i = 2; i < all_lines.Length; i++)
                {
                    string[] part = all_lines[i].Split(',');
                    Mypoints p = new Mypoints
                    {
                        name = part[0],
                        x = double.Parse(part[1]),
                        y = double.Parse(part[2]),
                        h = double.Parse(part[3])
                    };
                    allPoints.Add(p);
                    dataGridView1.Rows.Add(part[0], part[1], part[2], part[3]);
                }
                toolStripStatusLabel1.Text = "导入成功!";
                toolStripStatusLabel2.Text = "基准高程:" + jzH;
            }
            catch
            {
                MessageBox.Show("导入失败");
                return;
            }
        }

        private void 计算三角网及体积ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("正在计算，请稍后");
            if (allPoints.Count < 3)
            {
                MessageBox.Show("至少需要三个点才能计算凸包！");
                return;
            }

            // 找到最下方的点，作为基点
            Mypoints P0 = allPoints.OrderBy(p => p.y).ThenBy(p => p.x).First();

            // 排序其他点
            List<Mypoints> sortedPoints = allPoints.Where(p => p != P0).ToList();
            sortedPoints.Sort((p1, p2) =>
            {
                double angle1 = Math.Atan2(p1.y - P0.y, p1.x - P0.x);
                double angle2 = Math.Atan2(p2.y - P0.y, p2.x - P0.x);

                if (angle1 == angle2)
                {
                    double distance1 = Distance(P0, p1);
                    double distance2 = Distance(P0, p2);
                    return distance2.CompareTo(distance1); // 保证按距离从远到近排列
                }
                return angle1.CompareTo(angle2); // 按角度排序
            });

            List<Mypoints> convexHull = new List<Mypoints> { P0, sortedPoints[0], sortedPoints[1] };

            foreach (var p in sortedPoints.Skip(2))
            {
                while (convexHull.Count >= 2 && CrossProduct(convexHull[convexHull.Count - 2], convexHull[convexHull.Count - 1], p) <= 0)
                {
                    convexHull.RemoveAt(convexHull.Count - 1);
                }
                convexHull.Add(p);
            }

            // 构建初始三角形
            List<Mypoints> innerPoints = allPoints.Where(p => !convexHull.Contains(p)).ToList();
            foreach (var p in innerPoints)
            {
                foreach (var edge in convexHull.Select((point, index) => new { point, index }))
                {
                    var triangle = new Triangle(p, edge.point, convexHull[(edge.index + 1) % convexHull.Count]);
                    T1.Add(triangle);
                }
            }

            // 生成三角网并移除无效三角形
            foreach (var p in innerPoints)
            {
                List<Triangle> tempT1 = new List<Triangle>(T1);
                foreach (var triangle in tempT1)
                {
                    double[] circumcenter = CalculateCircumcenter(triangle);
                    double x0 = circumcenter[0];
                    double y0 = circumcenter[1];
                    double r = circumcenter[2];
                    if (IsInsideCircumcircle(p, x0, y0, r))
                    {
                        T1.Remove(triangle);
                        T2.Add(triangle);
                    }
                }
                UpdateEdgesAndTriangles(T2, S, p);
            }

            RemoveSmallOrLargeTriangles(T1); 
            toolStripStatusLabel1.Text = "不规则三角网生成完成！";
            OutputFirstTwentyTriangles();
            richTextBox1.Clear();

            double balanceElevation = CalculateBalanceElevation(T1);
            richTextBox1.AppendText($"平衡高程: {balanceElevation}\n");

            double referenceHeight = double.Parse(jzH);
            CalculateCutFillVolume(T1, referenceHeight);
            DrawConvexHullPoints(convexHull);

            DrawTrianglesOnChart(T1);
            MessageBox.Show("完成！");
        }
        private void DrawConvexHullPoints(List<Mypoints> convexHull)
        {
            chart2.Series.Clear(); 

            var convexHullSeries = new System.Windows.Forms.DataVisualization.Charting.Series
            {
                Name = "ConvexHullPoints",
                ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Point,
                MarkerStyle = System.Windows.Forms.DataVisualization.Charting.MarkerStyle.Circle,
                MarkerSize = 10, 
                BorderWidth = 3, 
                Color = System.Drawing.Color.Red 
            };

            foreach (var point in convexHull)
            {
                convexHullSeries.Points.AddXY(point.x, point.y);
            }

            chart2.Series.Add(convexHullSeries);
            chart2.ChartAreas[0].AxisY.Minimum = 2800;
            chart2.ChartAreas[0].AxisY.Maximum = 3000;
        }

        private void DrawTrianglesOnChart(List<Triangle> triangles)
        {
            chart1.Series.Clear(); 

            var series = new System.Windows.Forms.DataVisualization.Charting.Series
            {
                Name = "Triangles",
                ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line,
                BorderWidth = 2
            };

            foreach (var triangle in triangles)
            {
                AddTriangleEdgesToChart(triangle, series);
            }

            chart1.Series.Add(series);
        }

        private void AddTriangleEdgesToChart(Triangle triangle, System.Windows.Forms.DataVisualization.Charting.Series series)
        {
            AddEdgeToChart(triangle.A, triangle.B, series);
            AddEdgeToChart(triangle.B, triangle.C, series);
            AddEdgeToChart(triangle.C, triangle.A, series);
        }

        private void AddEdgeToChart(Mypoints p1, Mypoints p2, System.Windows.Forms.DataVisualization.Charting.Series series)
        {
            series.Points.AddXY(p1.x, p1.y);  // 起点
            series.Points.AddXY(p2.x, p2.y);  // 终点
        }

        private double CalculateBalanceElevation(List<Triangle> triangles)
        {
            double numerator = 0;
            double denominator = 0;

            foreach (var triangle in triangles)
            {
                double avgHeight = (triangle.A.h + triangle.B.h + triangle.C.h) / 3;
                double area = CalculateTriangleArea(triangle);
                numerator += avgHeight * area;
                denominator += area;
            }

            return numerator / denominator;
        }

        private double CalculateTriangleArea(Triangle triangle)
        {
            double x1 = triangle.A.x, y1 = triangle.A.y;
            double x2 = triangle.B.x, y2 = triangle.B.y;
            double x3 = triangle.C.x, y3 = triangle.C.y;

            return Math.Abs((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2.0;
        }
        private void CalculateCutFillVolume(List<Triangle> triangles, double referenceHeight)
        {
            foreach (var triangle in triangles)
            {
                double avgHeight = (triangle.A.h + triangle.B.h + triangle.C.h) / 3;
                double area = CalculateTriangleArea(triangle);

                double deltaHeight = avgHeight - referenceHeight;
                if (deltaHeight > 0)
                {
                    // 填方
                    double fillVolume = area * deltaHeight;
                    richTextBox1.Text+=($"三角形: {triangle.A.name}, {triangle.B.name}, {triangle.C.name} 填方体积: {fillVolume}\n");
                }
                else
                {
                    // 挖方
                    double cutVolume = area * (-deltaHeight);
                    richTextBox1.Text += ($"三角形: {triangle.A.name}, {triangle.B.name}, {triangle.C.name} 挖方体积: {cutVolume}\n");
                }
            }
        }

       
        private void OutputFirstTwentyTriangles()
        {
            var trianglesToDisplay = T1.Take(20).ToList(); // 获取前20个三角形
            foreach (var triangle in trianglesToDisplay)
            {
                string triangleText = $"三角形: {triangle.A.name}, {triangle.B.name}, {triangle.C.name}\n";
                richTextBox1.Text+=triangleText;
            }

            richTextBox1.Text += "前20个三角形已显示";
        }

        private double[] CalculateCircumcenter(Triangle triangle)
        {
            double x1 = triangle.A.x, y1 = triangle.A.y;
            double x2 = triangle.B.x, y2 = triangle.B.y;
            double x3 = triangle.C.x, y3 = triangle.C.y;

            double d = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2));
            double x0 = ((Math.Pow(x1, 2) + Math.Pow(y1, 2)) * (y2 - y3) + (Math.Pow(x2, 2) + Math.Pow(y2, 2)) * (y3 - y1) + (Math.Pow(x3, 2) + Math.Pow(y3, 2)) * (y1 - y2)) / d;
            double y0 = ((Math.Pow(x1, 2) + Math.Pow(y1, 2)) * (x3 - x2) + (Math.Pow(x2, 2) + Math.Pow(y2, 2)) * (x1 - x3) + (Math.Pow(x3, 2) + Math.Pow(y3, 2)) * (x2 - x1)) / d;
            double r = Math.Sqrt(Math.Pow(x0 - x1, 2) + Math.Pow(y0 - y1, 2));

            return new double[] { x0, y0, r };
        }

        private double Distance(Mypoints p1, Mypoints p2)
        {
            return Math.Sqrt(Math.Pow(p2.x - p1.x, 2) + Math.Pow(p2.y - p1.y, 2));
        }

        private double CrossProduct(Mypoints p1, Mypoints p2, Mypoints p3)
        {
            return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
        }

        private bool IsInsideCircumcircle(Mypoints p, double x0, double y0, double r)
        {
            return Math.Pow(p.x - x0, 2) + Math.Pow(p.y - y0, 2) < Math.Pow(r, 2);
        }

        private void UpdateEdgesAndTriangles(List<Triangle> T2, List<Edge> S, Mypoints p)
        {
            foreach (var triangle in T2)
            {
                AddEdge(triangle, S);
            }

            T2.Clear();
            foreach (var edge in S)
            {
                var newTriangle = new Triangle(edge.P1, edge.P2, p);
                T1.Add(newTriangle);
            }
            S.Clear();
        }

        private void AddEdge(Triangle triangle, List<Edge> edgeList)
        {
            AddEdgeToList(triangle.A, triangle.B, edgeList);
            AddEdgeToList(triangle.B, triangle.C, edgeList);
            AddEdgeToList(triangle.C, triangle.A, edgeList);
        }

        private void AddEdgeToList(Mypoints p1, Mypoints p2, List<Edge> edgeList)
        {
            if (!edgeList.Any(e => (e.P1 == p1 && e.P2 == p2) || (e.P1 == p2 && e.P2 == p1)))
            {
                edgeList.Add(new Edge(p1, p2));
            }
        }

        private void RemoveSmallOrLargeTriangles(List<Triangle> triangles)
        {
            triangles.RemoveAll(t =>
            {
                double angleA = CalculateAngle(t.A, t.B, t.C);
                double angleB = CalculateAngle(t.B, t.A, t.C);
                double angleC = CalculateAngle(t.C, t.A, t.B);
                return angleA < 5 || angleB < 5 || angleC < 5 || angleA > 160 || angleB > 160 || angleC > 160;
            });
        }

        private double CalculateAngle(Mypoints A, Mypoints B, Mypoints C)
        {
            double ab = Math.Sqrt(Math.Pow(A.x - B.x, 2) + Math.Pow(A.y - B.y, 2));
            double bc = Math.Sqrt(Math.Pow(B.x - C.x, 2) + Math.Pow(B.y - C.y, 2));
            double ac = Math.Sqrt(Math.Pow(A.x - C.x, 2) + Math.Pow(A.y - C.y, 2));
            return Math.Acos((ab * ab + bc * bc - ac * ac) / (2 * ab * bc)) * (180 / Math.PI);
        }

        private void toolStripButton4_Click(object sender, EventArgs e)
        {
            double xMin = chart1.ChartAreas[0].AxisX.Minimum;
            double xMax = chart1.ChartAreas[0].AxisX.Maximum;
            double yMin = chart1.ChartAreas[0].AxisY.Minimum;
            double yMax = chart1.ChartAreas[0].AxisY.Maximum;

            chart1.ChartAreas[0].AxisX.Minimum = xMin + (xMax - xMin) * 0.1;
            chart1.ChartAreas[0].AxisX.Maximum = xMax - (xMax - xMin) * 0.1;
            chart1.ChartAreas[0].AxisY.Minimum = yMin + (yMax - yMin) * 0.1;
            chart1.ChartAreas[0].AxisY.Maximum = yMax - (yMax - yMin) * 0.1;
        }

        private void toolStripButton5_Click(object sender, EventArgs e)
        {
            double xMin = chart1.ChartAreas[0].AxisX.Minimum;
            double xMax = chart1.ChartAreas[0].AxisX.Maximum;
            double yMin = chart1.ChartAreas[0].AxisY.Minimum;
            double yMax = chart1.ChartAreas[0].AxisY.Maximum;

            chart1.ChartAreas[0].AxisX.Minimum = xMin - (xMax - xMin) * 0.1;
            chart1.ChartAreas[0].AxisX.Maximum = xMax + (xMax - xMin) * 0.1;
            chart1.ChartAreas[0].AxisY.Minimum = yMin - (yMax - yMin) * 0.1;
            chart1.ChartAreas[0].AxisY.Maximum = yMax + (yMax - yMin) * 0.1;
        }

        private void chart1_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                isDragging = true;
                mouseDownLocation = e.Location;
            }
        }

        private void chart1_MouseMove(object sender, MouseEventArgs e)
        {
            if (isDragging)
            {
                // 计算鼠标移动的偏移量
                int deltaX = e.X - mouseDownLocation.X;
                int deltaY = e.Y - mouseDownLocation.Y;

                // 获取当前X轴和Y轴的最小最大值
                double xMin = chart1.ChartAreas[0].AxisX.Minimum;
                double xMax = chart1.ChartAreas[0].AxisX.Maximum;
                double yMin = chart1.ChartAreas[0].AxisY.Minimum;
                double yMax = chart1.ChartAreas[0].AxisY.Maximum;

                // 更新坐标轴的最小最大值来实现平移
                chart1.ChartAreas[0].AxisX.Minimum = xMin - deltaX * (xMax - xMin) / chart1.Width;
                chart1.ChartAreas[0].AxisX.Maximum = xMax - deltaX * (xMax - xMin) / chart1.Width;
                chart1.ChartAreas[0].AxisY.Minimum = yMin + deltaY * (yMax - yMin) / chart1.Height;
                chart1.ChartAreas[0].AxisY.Maximum = yMax + deltaY * (yMax - yMin) / chart1.Height;

                // 更新鼠标按下的位置
                mouseDownLocation = e.Location;
            }
        }

        private void chart1_MouseUp(object sender, MouseEventArgs e)
        {
            isDragging = false; // 结束拖动
        }

    }
}

namespace TIN_321
{
    public class Triangle
    {
        public Mypoints A { get; set; }
        public Mypoints B { get; set; }
        public Mypoints C { get; set; }

        public Triangle(Mypoints a, Mypoints b, Mypoints c)
        {
            A = a;
            B = b;
            C = c;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TIN_321
{
    public class Edge
    {
        public Mypoints P1 { get; set; }
        public Mypoints P2 { get; set; }

        public Edge(Mypoints p1, Mypoints p2)
        {
            P1 = p1;
            P2 = p2;
        }
    }
}
【ArcGIS风暴】ArcGIS 10.8中计算体积的方法总结
「 刘一哥与GIS的故事」
06-05 9708
ArcGIS 10.8提供了表面体积和面体积两种计算体积的方法。一、表面体积 用途：用于计算表面和参考平面之间区域的面积和体积。二、面体积 摘要：计算高度恒定的面和表面之间的体积和表面面积。
AE计算Tin的体积
weixin_33874713的博客
12-02 130
Public Sub SetSelectedRastersToSelfBaseHeight()    On Error GoTo eh        Dim pRLayer As IRasterLayer    Dim pLayer As ILayer    Dim i As Integer    Dim pLayersArray As IArray    Dim pDDD As I3DPrope...
Cesium 计算模型部分体积
资深三维GIS开发
09-10 4698
有时我们加载成功一个3dtiles模型之后，有时会有对模型体积进行计算的需求。今天花了点时间来写了这个功能，目前还没测试误差有多大。后面测试了再完善一下。说到原理其实和填挖方的原理差不多。 先看下效果：目前是在模型上绘制完面之后，alert了一下体积。 再看下模型侧面： 核心思想就是微分，webgl里的最小图元是三角形，故将这个面微分成多个三角形，然后计算每个三角形的面及每个三角形对...
ArcEngine TIN 量算projected Area,Volume, surface Area
cat_curio的专栏
04-17 875
/// /// 将整个TIN作为计算对象,使用此方法 /// /// TinLayer /// 参考面高度 public void CalculateAreaVolumeISurface(ITin Tin, double planeheight) { ISurf
TIN表面分析
qq1457346557的博客
07-04 2849
实习目的 使用Arctoolbox-3D Analyst工具-表面三角化中的工具进行TIN表面分析。 实习内容 两个TIN之间拉伸，提取TIN数据范围，剖面分析，定位异常三角形顶点（测量值），抽稀TIN结点（相当于随机采样数据选择重要点），坡向分析，坡度分析，表面差异，等高线 实习步骤 一、两个TIN之间拉伸 两个表面在水平方向重叠，在垂直方向拉伸。可以是点拉伸为三维的垂线，也可以是线拉伸为面，也可以是面拉伸为多面体。在地质构造可视化中有很好应用。 1、用vipoints的spot字段生成第一个TIN表面m
三角网生长算法构建TIN
~Up~
06-09 7077
三角网生长算法构建TIN（C#版）
2.1.1 ARCGIS创造TIN
qq_46703627的博客
01-18 3481
【ARCGIS】创建三角形不规则网络数据集 用法： 避免使用地理坐标系统创建TIN，因为当XY单位表示为球坐标时，Delaunay三角剖分规则无法有效执行。 表面特征类型定义了输入特征将如何帮助定义三角形曲面。 点特征可以指定为质量点，提供数据节点，其Z值用于曲面的三角剖分。 线特征可以指定为质量点和断线，它们表示沿坡面具有线性不连续的位置，如脊线、海岸线、路面边缘、建筑脚印等。 多边形特征也可以指定为质量点和断线，以及定义数据区域的剪辑特征，用恒定Z值替换定义区域的特征(例如水体)，并删除表明数据不存在的
转 不规则三角网（TIN） 慕名GIS
charleman的专栏
10-17 2419
不规则三角网（TIN） 分类： 3D建模&3D分析2012-12-06 09:29 2764人阅读 评论(0) 收藏 举报 Ⅰ 数字高程模型（DEM）         地球表面高低起伏，呈现一种连续变化的曲面，这种曲面无法用平面地图来确切表示。于是我们就利用一种全新的数字地球表面的方法—— 数字高程模型 的方法，这种方法已被普遍广泛采用。数字高程模型即DEM（Digi
记录下自己写的几个VB.NET小程序的心得
weixin_44705612的博客
08-17 1123
标题 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录标题前言一、部分小程序二、以不规则三角网体积计算为例介绍下程序的大体结构1.设计思路2.读入数据总结 前言 这个暑假我参加了专业的测绘技能大赛，并针对大赛的十个选题编写了vb.net环境下的小程序。编写的过程中不可避免的遇到很多问题，通过学习也基本解决，特此记录下以供参考。 提示：以下是本篇文章正文内容，下面案例可供参考 一、部分小程序 编写环境：Visual Studio 2013 1.不规则三角网体积计算（TIN) 2
TIN体积计算1
08-08
【不规则三角网（TIN）的构建与体积计算】 不规则三角网（TIN，Triangulated Irregular Network）是一种常用于地理信息系统（GIS）和计算机图形学中的数据结构，用于表示三维空间中的不规则表面。在TIN中，地形被...
编程在测绘中的应用之不规则三角网体积的计算 tin
09-10
综上所述，这个项目涵盖了编程语言（C#）、开发平台（.NET）、测绘方法（TIN体积计算）、CAD二次开发和软件工程等多个方面，对于学习和理解测绘领域的计算技术具有实践意义。通过深入研究和实践，开发者可以掌握如何...
不规则三角网法体积计算（完整C#+VS项目、数据读入显示、三角网绘制、TIN信息输出、土方计算）
05-11
1.完整的VS项目，采用VS2017编写； 2.C#语言开发； 3.可以构建不规则三角网，并进行土方计算； 4.采用可视化读文件方式，并用表格显示； 5.计算完成后实时绘制三角网；...6.可以输出TIN的点、边、三角形信息和土方量。
大赛——不规则三角网体积计算.zip
08-12
【VB.NET】编程语言在...通过学习和参考这个程序，开发者不仅可以了解如何在VB.NET环境中处理测绘数据，还能深入理解TIN体积计算的原理和实现步骤。同时，提供的各种辅助文件为理解程序功能和复现计算过程提供了便利。
利用构建不规则三角网（TIN）进行体积计算
04-13
本篇文章将详细探讨如何利用TIN进行体积计算，并结合给定的标签“测绘程序比赛”和“vs2015”，我们可以推测这是一个关于使用Visual Studio 2015开发测绘程序的项目。 首先，我们了解什么是不规则三角网。TIN是由多...
Spring Boot 启动流程深度解析：从源码到实践
三两肉的博客
05-28 1516
本文深入解析了Spring Boot的启动流程，从源码层面剖析了其核心机制。启动入口从@SpringBootApplication注解的main方法开始，通过SpringApplication.run()方法执行初始化，推断应用类型并加载初始器和监听器。run()方法的核心逻辑包括：准备环境、创建上下文、刷新上下文、发布启动事件等关键步骤。Spring Boot通过事件机制在不同启动阶段发布事件，允许开发者介入。文章通过详细代码示例展示了SpringApplication初始化、环境准备和上下文创建等核心流
Java基础之数组（附带Comparator）
2303_80236475的博客
06-03 161
数组中的每个元素都会被初始化为默认值，int 类型的就为 0，Object 类型的就为 null。不同数据类型的默认值不同。还有一个需要注意的是，Arrays.asList 方法返回的 ArrayList 并不是。只有创建对象时才会使用new关键字，所以数组是个对象。如果需要添加元素或者删除元素的话，需要把它转成。将数组转为List，使用Arrays类。自定义排序（使用Comparator）Arrays.sort（）方法。
MybatisPlus--核心功能--service接口
最新发布
m0_73856804的博客
06-03 726
这样我们就达到了白嫖的目的。注意事项：在编译简单接口时可以直接在controller层调用MyBatisPlus提供的Iservice接口方法实现，但是遇到一些业务逻辑复杂的业务时，需要编写自定义的业务逻辑时，就需要自定义service方法编写业务逻辑了，当我们的业务需要去编写自定义的SQL语句时，我们还需要去自定义方法，在mapper层实现方法。在这里结束后会有并发线程安全问题，如果有多个线程同时访问，两个用户，两条线程，都来进行对比，最后减去相同的数据，这样就会导致两条线程中只会被减去一个线程。
python学习（一）
qq_51412866的博客
06-03 189
本文总结了Python基础语法的关键知识点：1)字符串拼接的不同方式(+运算符、占位符%、f-string)；2)输入输出处理(input/print)；3)常用数据结构操作(列表、元组、字符串切片、集合、字典)；4)函数定义和使用(多返回值、参数传递、lambda)；5)文件读写(r/w/a模式)；6)异常处理机制；7)模块导入方式。内容涵盖Python基础数据类型操作、控制结构、函数式编程等核心概念，适合初学者快速掌握Python编程基础。
C++进阶--C++11（04）
2402_87779153的博客
05-29 1060
lambda表达式（格式，如何写，细节，底层），function（作用，格式，怎么写），bind（作用，格式，怎么写）
gis根据tin算体积
09-04
GIS（地理信息系统）可以根据TIN（三角网）算出地表或地形的体积。TIN是以三角形为基本单元的地理数据模型，它可以用来表示地理表面的形态和变化。在计算地表或地形体积时，GIS首先会根据采集到的地理数据构建TIN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xin2cd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值