c++多边形扫描线填充算法_基于MATLAB的道格拉斯普克算法递归实现

道格拉斯普克算法

(道格拉斯-普克)Douglas-Peukcer算法由D.Douglas和T.Peueker于1973年提出,是线状要素抽稀的经典算法。用它处理大量冗余的几何数据点,既可以达到数据量精简的目的,有可以在很大程度上保留几何形状的骨架。

递归算法

递归是一种代码运行的机制,简单来说就是函数自己调用自己实现有条件的迭代。在道格拉斯普克算法中,处理的原始数据为折线段,首先将折线段有条件的划分为两段(有条件所指的这个条件就是某点距离折线首尾连线距离足够远,也就是说这个点足够突出,抽稀时不可忽视,需要保留!)。以这个需要保留的特征点为分界点,将原始折线分成两段,每一段再调用当前函数继续提取特征点和进一步分段,直到所有特征点提取完毕,停止递归迭代。话不多说,上代码:

递归函数代码(ARecursionFun.m)

%% 设计一个递归函数(递归函数的定义初中学过,注意复习!!!),依次寻找特征点并存储
% 输入两个相邻特征点之间的扫描线pointsTab,特征点表A(A是折线首尾两个端点)
% 输出补充新发现的特征点后的特征点表A
% 函数名称为ARecursionFun(一个递归函数)
function [A] = ARecursionFun(pointsTab,A,Threshold)
[r,~] = size(pointsTab); % 获取扫描线片段上点的个数
if r > 2 % 如果这条扫描线片段上点数大于2则执行操作
Q1 = [pointsTab(1,1);pointsTab(1,2)]; % 起点坐标对的列向量表示(为了便于点到直线距离计算的表示方法)
Q2 = [pointsTab(r,1);pointsTab(r,2)]; % 终点坐标对的列向量表示(作用同上)
% 遍历这个扫描线,依次计算每个点到扫描线起点终点连线的距离==================
for i = 1:1:r
P = [pointsTab(i,1);pointsTab(i,2)]; % 当前点坐标的列向量表示
d(i,1) = abs(det([Q2-Q1,P-Q1]))/norm(Q2-Q1); % 计算点到直线的距离
end
% 计算完毕,每个点到直线的距离存入列向量d中================================
if max(d) > Threshold % 如果距离列向量中最大值大于阈值则进行下述操作
ind = find(all(repmat(max(d),size(d,1),1)==d,2)); % 获取列向量中最大值对应的点的序号
[rA,~] = size(A); % 获取当前特征点表A已存点的个数
A(rA+1,1) = pointsTab(ind,1); % 将这个点作为特征点存储起来(x坐标)
A(rA+1,2) = pointsTab(ind,2); % 将这个点作为特征点存储起来(y坐标)
%{
到上述步骤的时候其实就是一条扫描线上找到了距离扫描线首尾连线最远的那一个点并存储起来
你应该是看得懂的!!!
接下来两句则是该函数,或者说是该类函数(递归函数)的精髓,加几个断点,认真看!!!
%}
pointsTabb = pointsTab(1:ind,:); % 以刚才存储的特征点为界限,起点到该点建立新的片段扫描线
A = ARecursionFun(pointsTabb,A,Threshold); % 函数自身调用进行递归,进一步获取片段内的特征点
pointsTabe = pointsTab(ind:r,:); % 以刚才存储的特征点为界限,该点到终点建立新的片段扫描线
A = ARecursionFun(pointsTabe,A,Threshold); % 函数自身调用进行递归,进一步获取片段内的特征点
end
end

调用函数(main.m)

%% 主函数入口(在该函数界面下点击运行实验)
%{
程序运行结果图中,黑色线为原始扫描线的连线,红色*为获取的特征点
红色线为特征点连线
工作区中,points为扫描线点集,A为特征点集合
%}
clc;clear;close all; %清空所有变量,开始崭新的工作!!
% 模拟一条折线(用的时候替换成你自己的就行)=================================
points(:,1) = 5:5:300; %x值为1到60
points(:,2) = 10 + 3 * rand(60,1); %y为10加一个0到1的随机数
points(25:35,2) = 5 + 3 * rand(11,1); %其中第25到第35个点低一点
% =========================================================================
[r,c] = size(points);
A(1,1) = points(1,1); A(1,2) = points(1,2);
A(2,1) = points(r,1); A(2,2) = points(r,2);
Threshold = 3; %给定阈值
[A] = ARecursionFun(points,A,Threshold); % 递归
A = sortrows(A,1);
figure(1); %创建图层
plot(points(:,1),points(:,2),’-k’); %绘制原始折线
hold on; %保留当前图层的要素
plot(A(:,1),A(:,2),’*-r’); %在原图基础上绘制特征点
title([‘阈值为:’,num2str(Threshold)]);
msgbox ‘运行完毕!’;

处理结果

2e127eba2f5baa3691a51cdb904b770e.png

3bf268101dee19e729dfd9fcba14bb96.png

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Douglas-Peucker算法可以用C语言实现,以下是其中一个可能的实现: ```c #include <stdio.h> #include <stdlib.h> #include <math.h> typedef struct { double x; double y; } Point; // 计算点p1和点p2之间的欧几里得距离 double distance(Point p1, Point p2) { double dx = p1.x - p2.x; double dy = p1.y - p2.y; return sqrt(dx*dx + dy*dy); } // 计算点p到线段(p1,p2)的距离 double perpendicularDistance(Point p, Point p1, Point p2) { double area = fabs((p2.x-p1.x)*(p1.y-p.y)-(p1.x-p.x)*(p2.y-p1.y)); double lineLength = distance(p1, p2); return area / lineLength; } // 递归调用Douglas-Peucker算法 void douglasPeucker(Point* points, int start, int end, double epsilon, int* keep) { // 如果只有两个点,直接保留 if (end - start == 1) { keep[start] = 1; keep[end] = 1; return; } // 找出距离直线最远的点 double maxDistance = 0; int maxIndex = 0; Point p1 = points[start]; Point p2 = points[end]; for (int i = start+1; i < end; i++) { double d = perpendicularDistance(points[i], p1, p2); if (d > maxDistance) { maxDistance = d; maxIndex = i; } } // 如果最远距离大于epsilon,则继续递归,否则保留 if (maxDistance > epsilon) { douglasPeucker(points, start, maxIndex, epsilon, keep); douglasPeucker(points, maxIndex, end, epsilon, keep); } else { for (int i = start; i <= end; i++) { keep[i] = 1; } } } // Douglas-Peucker算法的入口函数 void simplify(Point* points, int n, double epsilon, Point** result, int* m) { // 先分配一个足够大的数组保留结果 int* keep = (int*)malloc(n * sizeof(int)); // 递归调用Douglas-Peucker算法 douglasPeucker(points, 0, n-1, epsilon, keep); // 统计结果 *m = 0; for (int i = 0; i < n; i++) { if (keep[i]) { (*m)++; } } *result = (Point*)malloc((*m) * sizeof(Point)); int j = 0; for (int i = 0; i < n; i++) { if (keep[i]) { (*result)[j++] = points[i]; } } free(keep); } int main() { Point points[] = { {0, 0}, {1, 1}, {2, 0}, {3, 1}, {4, 0}, {5, 1}, {6, 0}, {7, 1}, {8, 0}, {9, 1} }; int n = sizeof(points) / sizeof(Point); Point* simplifiedPoints; int m; simplify(points, n, 0.5, &simplifiedPoints, &m); printf("Original points:\n"); for (int i = 0; i < n; i++) { printf("%.1f, %.1f\n", points[i].x, points[i].y); } printf("Simplified points:\n"); for (int i = 0; i < m; i++) { printf("%.1f, %.1f\n", simplifiedPoints[i].x, simplifiedPoints[i].y); } free(simplifiedPoints); return 0; } ``` 该实现中,首先定义了一个结构体 `Point` 表示维空间中的一个点,然后实现了 `distance` 函数用于计算点与点之间的距离,以及 `perpendicularDistance` 函数用于计算点到线段的垂直距离。 接下来是Douglas-Peucker算法的核心部分,实现了一个 `douglasPeucker` 函数用于递归调用算法,并实现了一个 `simplify` 函数作为入口函数。输入参数为原始点数组 `points`,点数量 `n`,阈值 `epsilon`,输出参数为简化后的点数组 `result` 和点数量 `m`。算法先分配一个 `keep` 数组用于标记需要保留的点,然后调用 `douglasPeucker` 函数进行递归计算。最后统计保留的点数量并返回简化后的点数组即可。 在 `main` 函数中,我们定义了一个包含10个点的测试数组,并调用 `simplify` 函数进行简化,然后打印出原始点和简化后的点供查看。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值