把描述直角坐标系上的一个点的类作为基类派生出描述一条直线的泪和一个描述三角形的类定义成员函数，要求两点间的距离和三角形的面积
题目要求
把描述直角坐标系上的一个点的类作为基类派生出描述一条直线的泪和一个描述三角形的类定义成员函数，要求两点间的距离和三角形的面积



#include<iostream>
#include<string>
#include<cmath>
using namespace std;

class Point
{
protected:
    int x1, y1;
public:
    Point(int a, int b)
    {
        x1 = a; y1 = b;
    }
};

class Line :public Point
{
protected:
    int x2, y2;
public:
    Line(int a, int b, int c, int d) :Point(a, b), x2(c), y2(d) {}
};

class Triangle :public Line
{
protected:
    int x3, y3;
    double area;
public:
    Triangle(int a, int b, int c, int d, int e, int f) :Line(a, b, c, d), x3(e), y3(f) {}
    void f() {
        double x, y, z, s;
        x = sqrt((double)(x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
        y = sqrt((double)(x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
        z = sqrt((double)(x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));
        s = (x + y + z) / 2;
        area = sqrt(s * (s - x) * (s - y) * (s - z));
    }

    void print()
    {
        cout << "(" << x1 << "," << y1 << ")" << "(" << x2 << "," << y2 << ")" << "(" << x3 << "," << y3 << ")" << endl;
        cout << "area=" << area << endl;
    }
};


int main()
{
    int a[6];
    for (int i = 0; i < 6; i++)
        cin >> a[i];
    Triangle tri(a[0], a[1], a[2], a[3], a[4], a[5]);
    tri.f();
    tri.print();
    return 0;
}

圆上有n个点到直线的距离为d
圆 
 上到直线 
 的距离为 
 的点有（    ）个
方法一：常规方法，画图分析
由图象可以明显看出，圆在直线上方的部分内没有满足题意的点，在直线下方的部分内有两个满足题意的点。
但是这样的方法并不使用于一般题型，尤其是图象并不明显的题型。那有没有什么代数方法可以做呢？
方法二：三角换元
盯着关键词--“圆上的点”，那我们可以设圆上的点为 
，但是这样的话存在两个未知数，可以做下去，但是相对比较麻烦。
我们可以参考选修4-4中，参数方程的方法，设圆上的点为 
 , 
 ,这样圆上的点到直线的距离可以利用公式表示为：
 （舍）, 
 ，其中 
在 
 内在两个解
方法三：（我最推荐的方法）直线的轨迹方程
盯着关键词：“到直线 
 的距离为 
 的点”，这样的点的轨迹应该是和直线 
 平行的两条直线吧
不难求两条直线分别为 
 、 
圆心到 
 的距离 
 ,与圆没有交点
圆心到 
 的距离 
，与圆有两个交点
一共两个点复合题意
类似的题型：

在实现TextMountain时，生成TCBP时需要计算文本区域点到四条边的距离，由于计算量大，所以最好是使用矩阵运算，提高运行效率。
基础讲解：
由于需要使用到矩阵运算，最好采用向量的方法来进行表示。
为了讲述方便，我们设直线为x轴，用向量oq表示，对于点p，要计算p到直线oq的距离，我们可以任取直线上一点(这里取o)得到向量op，根据图中公式可以求得点到直线的垂足d到点p的向量dp(x,y),则点到直线的距离为sqrt(xx+yy)
编程实现
def get_pt_line_dis(pt, line, lpt):
'''
获取点到直线的距离
:param pt: 点坐标，[n,2]
:param line: 直线向量 [m,2]
:param lpt: 直线上的一个点 [m,2]
:return: 点与直线的距离以及直线到点的垂直单位向量
'''
EPS=10-9
pt = np.tile(pt[:, np.newaxis, :], (1, line.shape[0], 1)) #[n,m,2]
line = np.tile(line[np.newaxis, ...], (pt.shape[0], 1, 1)) #[n,m,2]
lpt = np.tile(lpt[np.newaxis, ...], (pt.shape[0], 1, 1)) #[n,m,2]
array_trans = pt - lpt #[n,m,2] array_trans[i,j]表示第i个点与第j条直线某端点组成的向量，图中op
array_temp = np.sum(array_trans * line, axis=2) / (line[..., 0] ** 2 + line[..., 1] ** 2) #[n,m]
array_temp = np.tile(array_temp[..., np.newaxis], (1, 1, 2)) #[n,m,2]
array_temp = array_temp * line #[n,m,2]计算图中od
v = array_trans - array_temp #图中dp [n,m,2] v[i,j]表示第i个点与第j条直线的垂直向量
distance = np.linalg.norm(v, axis=2)
v = v / (distance[..., np.newaxis] + EPS)
return distance, v

问题描述：

平常为了得出地理位置上两点的实际距离（譬如北京与杭州之间的实际距离），除了利用经纬度计算出两点的空间距离，还需要考虑地形因素。由于之间考虑地形造成误差较大，因此采用微分的办法来解决，简单来说就是将两点细分为多点间的距离（当然这个多点是有限的）。



图中计算AB之间的距离，可以计算出中间多个点位的距离（如AC），然后计算在AB直线上的投影。在此之前，需要计算出球面上两条直线间的夹角以及两点在球面上的距离。
1）球面上两条直线间的夹角

方法一：简易版，将球面弧线看成是直角坐标系下的直线，采用向量乘积。角度a = arc cos (a1a2/|a1||a2|)

方法二：将球面坐标系转为三维笛卡尔坐标系，然后利用向量乘积求角度。

这里考虑到向量的方向性及准确性，采用方法二会更好点。
def latlong_to_3d(latr,lonr):
    """Convert a point given latitude and longitude in radians to
    3-dimensional space,assuming a sphere radius of one."""
    return np.array((
        math.cos(latr) * math.cos(lonr),math.cos(latr) * math.sin(lonr),math.sin(latr)
    ))
def angle_between_vectors_degrees(u,v):
    """Return the angle between two vectors in any dimension space,in degrees."""
    return np.degrees(
        math.acos(np.dot(u,v) / (np.linalg.norm(u) * np.linalg.norm(v))))
# Convert the points to numpy latitude/longitude radians space
a = np.radians(np.array(A))
b = np.radians(np.array(B))
c = np.radians(np.array(C))

# The points in 3D space
a3 = latlong_to_3d(*a)
b3 = latlong_to_3d(*b)
c3 = latlong_to_3d(*c)
# Vectors in 3D space
a3vec = a3 - b3
c3vec = c3 - b3
# Find the angle between the vectors in 2D space
angle3deg = angle_between_vectors_degrees(a3vec,c3vec)

2)两点间的距离

S=R·arc cos[cosβ1cosβ2cos（α1-α2）+sinβ1sinβ2]

具体原理见球面两点距离原理
或是采用google map办法：

地球上任两点，其经度分别为A1、A2（E正，W负），纬度分别为B1、B2（N正，S负)。

令A0=（A1-A2）÷2，B0=（BI-B2）÷2

f=√sinB0×sinB0+cosB1×cosB2×sinA0×sinA0

S = 2Rf
在依次计算逐个站点在直线上的投影，然后考虑两点间的高程数据，进行累加得到AB间实际距离。

附上代码如下：
import pandas as pd
from dbfread import DBF
import os
import numpy as np
from math import radians, cos, sin, asin, sqrt
import math

def geodistance(lng1,lat1,lng2,lat2):
    lng1, lat1, lng2, lat2 = map(radians, [float(lng1), float(lat1), float(lng2), float(lat2)]) # 经纬度转换成弧度
    dlon=lng2-lng1
    dlat=lat2-lat1
    a=sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    distance=2*asin(sqrt(a))*6371*1000 # 地球平均半径，6371km
    #distance=round(distance/1000,3)
    return distance

def latlong_to_3d(latr,lonr):
    """Convert a point given latitude and longitude in radians to
    3-dimensional space,assuming a sphere radius of one."""
    return np.array((
        math.cos(latr) * math.cos(lonr),math.cos(latr) * math.sin(lonr),math.sin(latr)
    ))
def angle_between_vectors_degrees(u,v):
    """Return the angle between two vectors in any dimension space,in degrees."""
    return np.degrees(
        math.acos(np.dot(u,v) / (np.linalg.norm(u) * np.linalg.norm(v))))

path = r'D:\20210208'
filetype = '.dbf'#指定文件类型
total=[]
def get_filename(path,filetype):
    name =[]
    final_name = []
    for root,dirs,files in os.walk(path):
        for i in files:
            if filetype in i:
                name.append(i.replace(filetype,''))#生成不带‘.csv’后缀的文件名组成的列表
    final_name = [item +'.dbf' for item in name]#生成‘.csv’后缀的文件名组成的列表
    return final_name#输出由有‘.csv’后缀的文件名组成的列表

path_all = get_filename(path,filetype)
for j in path_all:
    table = DBF(path + '/' + j) #, encoding='GBK')
    df = pd.DataFrame(iter(table))
    total_distance = 0.0
    total_distance_plain = 0.0
    A = (df['POINT_Y'][0],df['POINT_X'][0])
    B = (df['POINT_Y'][len(df)-1],df['POINT_X'][len(df)-1])
    a = np.radians(np.array(A))
    b = np.radians(np.array(B))
    for n in range(len(df)-1):
        C = (df['POINT_Y'][n],df['POINT_X'][n])
        D = (df['POINT_Y'][n+1],df['POINT_X'][n+1])
        c = np.radians(np.array(C))
        d = np.radians(np.array(D))
        print(j,A,B,C,D)
        # The points in 3D space
        a3 = latlong_to_3d(*a)
        b3 = latlong_to_3d(*b)
        c3 = latlong_to_3d(*c)
        d3 = latlong_to_3d(*d)
        # Vectors in 3D space
        b3vec = b3 - a3
        d3vec = d3 - a3
        if D == B:
            angle3deg_a = 0
        else:
            # Find the angle between the vectors in 2D space
            angle3deg_a = angle_between_vectors_degrees(b3vec,d3vec)
        
        # Vectors in 3D space
        a3vec = a3 - d3
        c3vec = c3 - d3
        if C == A:
            angle3deg_d = 0
        else:
            # Find the angle between the vectors in 2D space
            angle3deg_d = angle_between_vectors_degrees(a3vec,c3vec)
        if angle3deg_d < 90:
            angle3deg = angle3deg_a + angle3deg_d
        else:
            angle3deg = angle3deg_a + 180 - angle3deg_d
        x = geodistance(df['POINT_X'][n],df['POINT_Y'][n],df['POINT_X'][n+1],df['POINT_Y'][n+1])
        h = df['GRID_CODE'][n]-df['GRID_CODE'][n+1]
        x_t = x*cos(angle3deg)
        l = (x_t*x_t+h*h)**0.5
        total_distance = total_distance+l#地表距离
        total_distance_plain = total_distance_plain+x#弧面距离
    total.append((j,total_distance)) 
print(total)