एक व्यापक विश्लेषण के आधार पर एक समोच्च में एक बिंदु का निर्धारण करने के लिए एल्गोरिदम

सभी हब्र लोगों को नमस्कार। मैं अपने सम्मानित पाठकों को एक उदाहरण पेश करना चाहता हूं, जब हमारी समझ में, उच्च गणित जो सूखा था और जीवन से बहुत दूर था, एक बुरा व्यावहारिक परिणाम नहीं दिया।

पहले कुछ यादें

यह तब था जब मैं 90 के दशक में तकनीकी विश्वविद्यालयों में से एक का छात्र था, शायद दूसरा पाठ्यक्रम। मैं एक बार प्रोग्रामिंग ओलंपियाड के पास गया। और इस ओलंपिक में, कार्य था: त्रिकोण के निर्देशांक सेट करना, विमान पर परीक्षण बिंदु, और यह निर्धारित करना कि यह बिंदु त्रिकोण के क्षेत्र से संबंधित है या नहीं। सामान्य तौर पर, एक trifling कार्य, लेकिन तब मैंने इसे हल नहीं किया था। लेकिन फिर मैंने सोचा - एक अधिक सामान्य कार्य पर - लैंडफिल से संबंधित। मैं दोहराता हूं - 90 के दशक के मध्य था, कोई इंटरनेट नहीं था, कंप्यूटर ज्यामिति पर कोई किताबें नहीं थीं, लेकिन टॉवर पर व्याख्यान और टर्बो पास्कल के साथ 286-x प्रयोगशाला थी। और इसलिए सितारों ने संयोग किया, कि जिस समय मैं समस्या के बारे में सोच रहा था, उस टावर पर हम एक जटिल चर के सिद्धांत को पढ़ रहे थे। और एक सूत्र (इसके बारे में नीचे) उपजाऊ जमीन पर गिर गया। एल्गोरिथ्म पास्कल में आविष्कार किया गया था और लागू किया गया था (दुर्भाग्य से मेरे डेढ़ गिग पेंच मर गए और इस कोड और गुमनामी के लिए मेरी अन्य युवा उपलब्धियों का एक गुच्छा लिया)। स्नातक स्तर की पढ़ाई के बाद, मैंने एक शोध संस्थान में काम करना समाप्त कर दिया। वहां मुझे संस्थान के कर्मचारियों की जरूरतों के लिए जीआईएस विकसित करना था, और मेरे अपने कार्यों में से एक यह निर्धारित करना था कि क्या ऑब्जेक्ट सर्किट में प्रवेश करते हैं। एल्गोरिथ्म C ++ में फिर से लिखा गया था और काम में खुद को साबित किया है।

एल्गोरिथ्म के लिए कार्य

दिए गए:

गेम - इसके कोने (xi, yi) के निर्देशांक और परीक्षण बिंदु (x0, y0) के समन्वय द्वारा परिभाषित विमान पर बंद पॉलीलाइन (इसके बाद बहुभुज)

निर्धारित करें:

क्या बिंदु बहुभुज द्वारा घिरे क्षेत्र डी का है।

किसी भी तरह से एल्गोरिथम के बाद के लेखन के लिए सूत्रों की व्युत्पत्ति गणितीय पूर्णता और सटीकता का दावा करती है, लेकिन केवल विज्ञान के क्षेत्रों की रानी के लिए इंजीनियरिंग (उपभोक्ता दृष्टिकोण) को प्रदर्शित करती है।

तो चलिए शुरू करते हैं

कॉची इंटीग्रल फॉर्मूला

कार्यकर्ता-किसान इंजीनियरिंग बिंदु से स्पष्टीकरण:
- सीमा जी हमारे दिए गए समोच्च हैं,
- z0 -तम बिंदु
- f (z) - एक जटिल तर्क का एक जटिल कार्य सर्किट में कहीं भी अनंत तक नहीं जाता है।

वे हैं, यह स्थापित करने के लिए कि बिंदु समोच्च से संबंधित है, हमें अभिन्न की गणना करने और किसी दिए गए बिंदु पर फ़ंक्शन के मूल्य के साथ तुलना करने की आवश्यकता है। यदि वे संयोग करते हैं, तो बिंदु समोच्च में निहित है। नोट: कॉची के अभिन्न प्रमेय में कहा गया है कि यदि बिंदु समोच्च में झूठ नहीं बोलता है, तो इंटीग्रैंड कहीं भी अनंत तक नहीं जाता है, तो अभिन्न शून्य है। यह मामले को सरल करता है - आपको केवल अभिन्न की गणना करने की आवश्यकता है और यह जांचना शून्य के बराबर है: गैर-समोच्च का बिंदु शून्य के बराबर है, यह अलग है - यह समोच्च में निहित है।
आइए हम अभिन्न की गणना करें। F (z) के लिए हम एक सरल कार्य करते हैं। 1. बिना सामान्यता के नुकसान के, हम z0 के लिए बिंदु 0 ले सकते हैं (आप हमेशा निर्देशांक को स्थानांतरित कर सकते हैं)।


हम अभिन्न के हर में काल्पनिक इकाई से छुटकारा पाते हैं और अभिन्न को वास्तविक और काल्पनिक भागों में विभाजित करते हैं:



यह दूसरी तरह के दो घुंघराले अभिन्न अंग निकला।
हम पहले की गणना करते हैं


अभिन्न जो पथ पर निर्भर नहीं करता है वह शर्त संतुष्ट है, इसलिए, पहला अभिन्न शून्य है और इसकी गणना करने की आवश्यकता नहीं है।

काल्पनिक भाग के साथ, ऐसी चाल काम नहीं करती है। हमें याद है कि हमारी सीमा में लाइन सेगमेंट शामिल हैं, हमें यह मिलता है:

जहाँ Gi- खंड (xi, yi) है - (xi + 1, y i + 1)
हम ith अभिन्न गणना करते हैं। ऐसा करने के लिए, हम ith खंड के समीकरण को एक पैरामीट्रिक रूप में लिखते हैं


अभिन्न में स्थानापन्न


और बोझिल और थकाऊ परिवर्तनों के बाद, हम निम्नलिखित आकर्षक सूत्र प्राप्त करते हैं:


हम अंततः प्राप्त करते हैं

C ++ एल्गोरिथम:

template < class T>
bool pt_in_polygon( const T &test,const std::vector &polygon)
{
if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();

T last_pt=polygon.back();

last_pt.x-=test.x;
last_pt.y-=test.y;

double sum=0.0;

for (
std::vector::const_iterator iter=polygon.begin();
iter!=end;
++iter
)
{
T cur_pt=*iter;
cur_pt.x-=test.x;
cur_pt.y-=test.y;

double del= last_pt.x*cur_pt.y-cur_pt.x*last_pt.y;
double xy= cur_pt.x*last_pt.x+cur_pt.y*last_pt.y;

sum+=
(
atan((last_pt.x*last_pt.x+last_pt.y*last_pt.y - xy)/del)+
atan((cur_pt.x*cur_pt.x+cur_pt.y*cur_pt.y- xy )/del)
);

last_pt=cur_pt;

}

return fabs(sum)>eps;

}



T – , :
struct PointD
{
double x,y;
};



2D : Anti-Grain Geometry (AGG) .

:
–
-
Shift- –

PS

, , . .
forgotten .
template bool pt_in_polygon2(const T &test,const std::vector &polygon)
{

static const int q_patt[2][2]= { {0,1}, {3,2} };

if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();
T pred_pt=polygon.back();
pred_pt.x-=test.x;
pred_pt.y-=test.y;

int pred_q=q_patt[pred_pt.y<0][pred_pt.x<0];

int w=0;

for(std::vector::const_iterator iter=polygon.begin();iter!=end;++iter)
{
T cur_pt = *iter;

cur_pt.x-=test.x;
cur_pt.y-=test.y;

int q=q_patt[cur_pt.y<0][cur_pt.x<0];

switch (q-pred_q)
{
case -3:++w;break;
case 3:--w;break;
case -2:if(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x) ++w;break;
case 2:if(!(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x)) --w;break;
}

pred_pt = cur_pt;
pred_q = q;

}

return w!=0;

}


template < class T>
bool pt_in_polygon( const T &test,const std::vector &polygon)
{
if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();

T last_pt=polygon.back();

last_pt.x-=test.x;
last_pt.y-=test.y;

double sum=0.0;

for (
std::vector::const_iterator iter=polygon.begin();
iter!=end;
++iter
)
{
T cur_pt=*iter;
cur_pt.x-=test.x;
cur_pt.y-=test.y;

double del= last_pt.x*cur_pt.y-cur_pt.x*last_pt.y;
double xy= cur_pt.x*last_pt.x+cur_pt.y*last_pt.y;

sum+=
(
atan((last_pt.x*last_pt.x+last_pt.y*last_pt.y - xy)/del)+
atan((cur_pt.x*cur_pt.x+cur_pt.y*cur_pt.y- xy )/del)
);

last_pt=cur_pt;

}

return fabs(sum)>eps;

}



T – , :
struct PointD
{
double x,y;
};



2D : Anti-Grain Geometry (AGG) .

:
–
-
Shift- –

PS

, , . .
forgotten .
template bool pt_in_polygon2(const T &test,const std::vector &polygon)
{

static const int q_patt[2][2]= { {0,1}, {3,2} };

if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();
T pred_pt=polygon.back();
pred_pt.x-=test.x;
pred_pt.y-=test.y;

int pred_q=q_patt[pred_pt.y<0][pred_pt.x<0];

int w=0;

for(std::vector::const_iterator iter=polygon.begin();iter!=end;++iter)
{
T cur_pt = *iter;

cur_pt.x-=test.x;
cur_pt.y-=test.y;

int q=q_patt[cur_pt.y<0][cur_pt.x<0];

switch (q-pred_q)
{
case -3:++w;break;
case 3:--w;break;
case -2:if(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x) ++w;break;
case 2:if(!(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x)) --w;break;
}

pred_pt = cur_pt;
pred_q = q;

}

return w!=0;

}


template < class T>
bool pt_in_polygon( const T &test,const std::vector &polygon)
{
if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();

T last_pt=polygon.back();

last_pt.x-=test.x;
last_pt.y-=test.y;

double sum=0.0;

for (
std::vector::const_iterator iter=polygon.begin();
iter!=end;
++iter
)
{
T cur_pt=*iter;
cur_pt.x-=test.x;
cur_pt.y-=test.y;

double del= last_pt.x*cur_pt.y-cur_pt.x*last_pt.y;
double xy= cur_pt.x*last_pt.x+cur_pt.y*last_pt.y;

sum+=
(
atan((last_pt.x*last_pt.x+last_pt.y*last_pt.y - xy)/del)+
atan((cur_pt.x*cur_pt.x+cur_pt.y*cur_pt.y- xy )/del)
);

last_pt=cur_pt;

}

return fabs(sum)>eps;

}



T – , :
struct PointD
{
double x,y;
};



2D : Anti-Grain Geometry (AGG) .

:
–
-
Shift- –

PS

, , . .
forgotten .
template bool pt_in_polygon2(const T &test,const std::vector &polygon)
{

static const int q_patt[2][2]= { {0,1}, {3,2} };

if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();
T pred_pt=polygon.back();
pred_pt.x-=test.x;
pred_pt.y-=test.y;

int pred_q=q_patt[pred_pt.y<0][pred_pt.x<0];

int w=0;

for(std::vector::const_iterator iter=polygon.begin();iter!=end;++iter)
{
T cur_pt = *iter;

cur_pt.x-=test.x;
cur_pt.y-=test.y;

int q=q_patt[cur_pt.y<0][cur_pt.x<0];

switch (q-pred_q)
{
case -3:++w;break;
case 3:--w;break;
case -2:if(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x) ++w;break;
case 2:if(!(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x)) --w;break;
}

pred_pt = cur_pt;
pred_q = q;

}

return w!=0;

}


template < class T>
bool pt_in_polygon( const T &test,const std::vector &polygon)
{
if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();

T last_pt=polygon.back();

last_pt.x-=test.x;
last_pt.y-=test.y;

double sum=0.0;

for (
std::vector::const_iterator iter=polygon.begin();
iter!=end;
++iter
)
{
T cur_pt=*iter;
cur_pt.x-=test.x;
cur_pt.y-=test.y;

double del= last_pt.x*cur_pt.y-cur_pt.x*last_pt.y;
double xy= cur_pt.x*last_pt.x+cur_pt.y*last_pt.y;

sum+=
(
atan((last_pt.x*last_pt.x+last_pt.y*last_pt.y - xy)/del)+
atan((cur_pt.x*cur_pt.x+cur_pt.y*cur_pt.y- xy )/del)
);

last_pt=cur_pt;

}

return fabs(sum)>eps;

}



T – , :
struct PointD
{
double x,y;
};



2D : Anti-Grain Geometry (AGG) .

:
–
-
Shift- –

PS

, , . .
forgotten .
template bool pt_in_polygon2(const T &test,const std::vector &polygon)
{

static const int q_patt[2][2]= { {0,1}, {3,2} };

if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();
T pred_pt=polygon.back();
pred_pt.x-=test.x;
pred_pt.y-=test.y;

int pred_q=q_patt[pred_pt.y<0][pred_pt.x<0];

int w=0;

for(std::vector::const_iterator iter=polygon.begin();iter!=end;++iter)
{
T cur_pt = *iter;

cur_pt.x-=test.x;
cur_pt.y-=test.y;

int q=q_patt[cur_pt.y<0][cur_pt.x<0];

switch (q-pred_q)
{
case -3:++w;break;
case 3:--w;break;
case -2:if(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x) ++w;break;
case 2:if(!(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x)) --w;break;
}

pred_pt = cur_pt;
pred_q = q;

}

return w!=0;

}


template < class T>
bool pt_in_polygon( const T &test,const std::vector &polygon)
{
if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();

T last_pt=polygon.back();

last_pt.x-=test.x;
last_pt.y-=test.y;

double sum=0.0;

for (
std::vector::const_iterator iter=polygon.begin();
iter!=end;
++iter
)
{
T cur_pt=*iter;
cur_pt.x-=test.x;
cur_pt.y-=test.y;

double del= last_pt.x*cur_pt.y-cur_pt.x*last_pt.y;
double xy= cur_pt.x*last_pt.x+cur_pt.y*last_pt.y;

sum+=
(
atan((last_pt.x*last_pt.x+last_pt.y*last_pt.y - xy)/del)+
atan((cur_pt.x*cur_pt.x+cur_pt.y*cur_pt.y- xy )/del)
);

last_pt=cur_pt;

}

return fabs(sum)>eps;

}



T – , :
struct PointD
{
double x,y;
};



2D : Anti-Grain Geometry (AGG) .

:
–
-
Shift- –

PS

, , . .
forgotten .
template bool pt_in_polygon2(const T &test,const std::vector &polygon)
{

static const int q_patt[2][2]= { {0,1}, {3,2} };

if (polygon.size()<3) return false;

std::vector::const_iterator end=polygon.end();
T pred_pt=polygon.back();
pred_pt.x-=test.x;
pred_pt.y-=test.y;

int pred_q=q_patt[pred_pt.y<0][pred_pt.x<0];

int w=0;

for(std::vector::const_iterator iter=polygon.begin();iter!=end;++iter)
{
T cur_pt = *iter;

cur_pt.x-=test.x;
cur_pt.y-=test.y;

int q=q_patt[cur_pt.y<0][cur_pt.x<0];

switch (q-pred_q)
{
case -3:++w;break;
case 3:--w;break;
case -2:if(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x) ++w;break;
case 2:if(!(pred_pt.x*cur_pt.y>=pred_pt.y*cur_pt.x)) --w;break;
}

pred_pt = cur_pt;
pred_q = q;

}

return w!=0;

}