| |
| |
| #if defined(_WIN32) |
| #define MCB_EXPORT extern "C" __declspec(dllexport) |
| #else |
| #define MCB_EXPORT extern "C" |
| #endif |
| #include <algorithm> |
| #include <cmath> |
| #include <cstdint> |
| #include <numeric> |
| #include <vector> |
| #include <stdexcept> |
| using namespace std; |
| struct IndexedMaxHeap { |
| vector<int> ids,pos; vector<double>& values; |
| IndexedMaxHeap(vector<double>&v,int excluded=-1):pos(v.size(),-1),values(v){ |
| for(int i=0;i<(int)v.size();i++)if(i!=excluded){pos[i]=ids.size();ids.push_back(i);} |
| for(int i=(int)ids.size()/2-1;i>=0;i--)down(i); |
| } |
| bool better(int a,int b)const{return values[a]>values[b]||(values[a]==values[b]&&a<b);} |
| void swap_at(int a,int b){swap(ids[a],ids[b]);pos[ids[a]]=a;pos[ids[b]]=b;} |
| void down(int a){for(;;){int b=2*a+1;if(b>=(int)ids.size())return;int c=b+1;if(c<(int)ids.size()&&better(ids[c],ids[b]))b=c;if(!better(ids[b],ids[a]))return;swap_at(a,b);a=b;}} |
| int pop(){int id=ids[0];pos[id]=-1;int last=ids.back();ids.pop_back();if(!ids.empty()){ids[0]=last;pos[last]=0;down(0);}return id;} |
| void decreased(int id){if(pos[id]>=0)down(pos[id]);} |
| }; |
| struct Node{double lo[3],hi[3],upper=0;int start,end,left=-1,right=-1;}; |
| struct KDTree { |
| const double* p; vector<int> order; vector<Node> nodes; |
| KDTree(const double*points,int n):p(points),order(n){iota(order.begin(),order.end(),0);nodes.reserve(n/4);build(0,n);} |
| double dist(int a,int b)const{double x=p[3*a]-p[3*b],y=p[3*a+1]-p[3*b+1],z=p[3*a+2]-p[3*b+2];return x*x+y*y+z*z;} |
| double min_box(int node,int query)const{double sum=0;const Node&t=nodes[node];for(int j=0;j<3;j++){double x=p[3*query+j],d=x<t.lo[j]?t.lo[j]-x:(x>t.hi[j]?x-t.hi[j]:0);sum+=d*d;}return sum;} |
| int build(int start,int end){Node t;t.start=start;t.end=end;for(int j=0;j<3;j++){t.lo[j]=INFINITY;t.hi[j]=-INFINITY;} |
| for(int i=start;i<end;i++)for(int j=0;j<3;j++){double x=p[3*order[i]+j];t.lo[j]=min(t.lo[j],x);t.hi[j]=max(t.hi[j],x);} |
| int index=nodes.size();nodes.push_back(t);if(end-start>16){int axis=0;for(int j=1;j<3;j++)if(t.hi[j]-t.lo[j]>t.hi[axis]-t.lo[axis])axis=j;int mid=(start+end)/2; |
| nth_element(order.begin()+start,order.begin()+mid,order.begin()+end,[&](int a,int b){return p[3*a+axis]<p[3*b+axis]||(p[3*a+axis]==p[3*b+axis]&&a<b);}); |
| int left=build(start,mid),right=build(mid,end);nodes[index].left=left;nodes[index].right=right;} |
| return index; |
| } |
| double initialize_upper(int node,const vector<double>& d){Node&t=nodes[node];if(t.left<0){double mx=0;for(int i=t.start;i<t.end;i++)mx=max(mx,d[order[i]]);return t.upper=mx;}return t.upper=max(initialize_upper(t.left,d),initialize_upper(t.right,d));} |
| void update_nearest(int node,int query,vector<double>&d,IndexedMaxHeap&heap){Node&t=nodes[node];if(min_box(node,query)>=t.upper)return; |
| if(t.left<0){double mx=0;for(int k=t.start;k<t.end;k++){int id=order[k];if(heap.pos[id]<0)continue;double fresh=dist(id,query);if(fresh<d[id]){d[id]=fresh;heap.decreased(id);}mx=max(mx,d[id]);}t.upper=mx;return;} |
| int a=t.left,b=t.right;if(min_box(a,query)>min_box(b,query))swap(a,b);update_nearest(a,query,d,heap);update_nearest(b,query,d,heap);t.upper=max(nodes[t.left].upper,nodes[t.right].upper); |
| } |
| template<class Callback>void radius_query(int node,int query,double radius2,Callback&cb)const{ |
| const Node&t=nodes[node];if(min_box(node,query)>radius2)return;if(t.left<0){for(int k=t.start;k<t.end;k++){int id=order[k];double d2=dist(id,query);if(d2<radius2)cb(id,d2);}return;} |
| radius_query(t.left,query,radius2,cb);radius_query(t.right,query,radius2,cb); |
| } |
| }; |
| MCB_EXPORT int exact_fps(const double*points,int n,int k,int32_t*selected){try{ |
| if(k<1||k>n)return 1;KDTree tree(points,n);vector<double>nearest(n);for(int i=0;i<n;i++)nearest[i]=tree.dist(i,0);IndexedMaxHeap heap(nearest,0);tree.initialize_upper(0,nearest);selected[0]=0; |
| for(int step=1;step<k;step++){int id=heap.pop();selected[step]=id;nearest[id]=0;tree.update_nearest(0,id,nearest,heap);}return 0; |
| }catch(...){return 2;}} |
| MCB_EXPORT int poisson_elimination(const double*points,int n,int k,double surface_area,int32_t*selected){try{ |
| if(k<1||k>n||surface_area<=0)return 1;KDTree tree(points,n);vector<double>weights(n,0); |
| double maximum=2*sqrt(surface_area/(k*2*sqrt(3.0)));double minimum=maximum*0.65*(1-pow(double(k)/n,1.5));double radius2=maximum*maximum; |
| auto weight=[&](double d2){double d=max(sqrt(d2),minimum);double x=max(0.0,1-d/maximum);double q=x*x;q*=q;return q*q;}; |
| for(int id=0;id<n;id++){auto sum=[&](int nb,double d2){if(nb!=id)weights[id]+=weight(d2);};tree.radius_query(0,id,radius2,sum);} |
| IndexedMaxHeap heap(weights);for(int remaining=n;remaining>k;remaining--){int id=heap.pop();auto decrement=[&](int nb,double d2){if(heap.pos[nb]>=0){weights[nb]=max(0.0,weights[nb]-weight(d2));heap.decreased(nb);}};tree.radius_query(0,id,radius2,decrement);} |
| int count=0;for(int id=0;id<n;id++)if(heap.pos[id]>=0)selected[count++]=id;return count==k?0:3; |
| }catch(...){return 2;}} |
|
|
