ऐसे बिंदु उत्पन्न करें जो बहुभुज के अंदर स्थित हों


30

मेरे पास बहुभुज सुविधा है और इसके अंदर अंक उत्पन्न करने में सक्षम होना चाहते हैं। मुझे एक वर्गीकरण कार्य के लिए इसकी आवश्यकता है।

जब तक एक बहुभुज के अंदर नहीं होता है तब तक यादृच्छिक अंक उत्पन्न करना काम नहीं करेगा क्योंकि यह वास्तव में अप्रत्याशित समय लगता है।


3
इसके विपरीत, समय पूर्वानुमेय है। यह बहुभुज के क्षेत्रफल से विभाजित बहुभुज के क्षेत्रफल के अनुपात के अनुपात में होता है, जो एकल बिंदु को उत्पन्न करने और परीक्षण करने के लिए आवश्यक समय है। समय थोड़ा भिन्न होता है, लेकिन भिन्नता अंकों की संख्या के वर्गमूल के समानुपाती होती है। लार्जिश संख्याओं के लिए, यह असंगत हो जाता है। यदि इस क्षेत्र के अनुपात को कम मूल्य पर प्राप्त करने के लिए आवश्यक हो तो अत्याधिक बहुभुजों को तोड़ दें। केवल भग्न बहुभुज आपको परेशानी देंगे, लेकिन मुझे संदेह है कि आपके पास है!
whuber



@ पाब्लो: अच्छा लगता है। हालांकि, उन सवालों के दोनों सॉफ्टवेयर विशिष्ट और दोनों चिंता बहुभुज के भीतर अंकों की नियमित सरणियों रखने, नहीं यादृच्छिक अंक हैं
whuber

एक बहुभुज के भीतर नियमित बिंदु पीढ़ी बनाम रंजक अंतर के साथ सहमत होना।
Mapperz

जवाबों:


20

बहुभुज को त्रिभुजों में विघटित करके शुरू करें, फिर उन के अंदर अंक उत्पन्न करें । (एक समान वितरण के लिए, प्रत्येक त्रिकोण को उसके क्षेत्र द्वारा भारित करें।)


2
+1 सरल और प्रभावी। यह इंगित करने के लायक है कि समान रूप से यादृच्छिक अंक एक त्रिकोण के भीतर उत्पन्न हो सकते हैं जिसमें कोई अस्वीकृति नहीं है, क्योंकि किसी भी त्रिभुज और समद्विबाहु दाएं त्रिकोण के बीच क्षेत्र-संरक्षण मैपिंग आसानी से होती है, जो आधा वर्ग है, आधा कहें y निर्देशांक x समन्वय से अधिक है। दो यादृच्छिक निर्देशांक बनाएं और उन्हें समद्विबाहु त्रिकोण में एक यादृच्छिक बिंदु प्राप्त करने के लिए सॉर्ट करें, फिर मूल त्रिकोण पर वापस जाएं।
whuber

+1 मैं वास्तव में आपके द्वारा उद्धृत लेख द्वारा संदर्भित ट्रिलाइनियर निर्देशांक की चर्चा पसंद करता हूं । मुझे लगता है कि यह गोलाकार होगा जिसकी सतह को त्रिकोण के एक टेसिलेशन के रूप में दर्शाया गया है। एक अनुमानित विमान पर, यह वास्तव में यादृच्छिक वितरण नहीं होगा, यह होगा?
किर्क कुएकेन्डल

@whuber - +1 आप पर। एक और तरीका (लिंक में, लेकिन वे उस पर हाथ लहराते हैं) साझा किनारे पर समान रूप से नमूने वाले चतुर्भुज से अस्वीकार किए गए बिंदुओं को प्रतिबिंबित करना और त्रिकोण में वापस करना है।
दान एस।

@ किर्क - प्रशस्ति पत्र एक स्पर्श विरोधी मददगार है कि यह "सही" तरीके से पहले ट्रिलिनियर निर्देशांक सहित गलत (गैर-वर्दी) नमूने के तरीकों का एक गुच्छा सूचीबद्ध करता है। ऐसा नहीं लगता है कि एक समान नमूना w / ट्रिलिनियर निर्देशांक प्राप्त करने का एक सीधा तरीका है। मैं 3 डी में यादृच्छिक इकाई वैक्टर को उनके लाट / लोन समतुल्य में परिवर्तित करके पूरे क्षेत्र में समान नमूना लेने के लिए संपर्क करूंगा, लेकिन यह सिर्फ मेरे लिए है। (गोलाकार त्रिकोण / बहुभुज के लिए विवश नमूने के बारे में अनिश्चित।) (उदाहरण के लिए wgs84 पर समान रूप से नमूने के बारे में भी अनिश्चित: बस कोण उठाने से डंडे के प्रति थोड़ा पूर्वाग्रह हो जाएगा, मुझे लगता है।)
दान एस।

1
@ समान क्षेत्र के नमूने के लिए, एक बेलनाकार समान क्षेत्र के प्रक्षेपण का उपयोग करें (निर्देशांक देशांतर और अक्षांश के कोसाइन हैं)। यदि आप एक प्रक्षेपण का उपयोग किए बिना नमूना करना चाहते हैं, तो एक सुंदर चाल है: तीन स्वतंत्र मानक सामान्य चर (x, y, z) उत्पन्न करें और उन्हें बिंदु पर प्रोजेक्ट करें (R x / n, R y / n, R * z / n ) जहाँ n ^ 2 = x ^ 2 + y ^ 2 + z ^ 2 और R पृथ्वी त्रिज्या है। यदि आवश्यक हो तो (लेट, लोन) में परिवर्तित करें (गोलाकार पर काम करते समय ऑटिस्टिक अक्षांश का उपयोग करना)। यह काम करता है क्योंकि यह सामान्य वितरण सामान्य रूप से गोलाकार है। नमूने त्रिकोण के लिए, एक प्रक्षेपण से चिपके रहते हैं।
whuber

14

जैसा कि आप इस प्रश्न पर एक QGIS टैग लगाते हैं: रैंडम पॉइंट टूल का उपयोग एक सीमा परत के साथ किया जा सकता है।

यहां छवि विवरण दर्ज करें

यदि आप कोड की तलाश कर रहे हैं, तो अंतर्निहित प्लगइन स्रोत कोड मदद का होना चाहिए।


1
5 साल बाद भी, अभी भी वास्तव में मददगार!
फंसे हुए बच्चे

10

आप बहुभुज की सीमा निर्धारित कर सकते हैं, फिर एक्स और वाई मूल्यों के लिए यादृच्छिक संख्या पीढ़ी को विवश कर सकते हैं।

आधारभूत प्रक्रिया: 1) अधिकतम, अधिकतम, न्यूनतम, बहुभुज की टकसाल की टकसाल, 2) निर्धारित करें, इन मानों को सीमा 3 के रूप में उपयोग करके यादृच्छिक बिंदु उत्पन्न करें) अपने बहुभुज के साथ चौराहे के लिए प्रत्येक बिंदु का परीक्षण करें, 4) जब आप पर्याप्त बिंदु चौराहा को संतुष्ट करते हैं तो उत्पादन बंद कर दें। परीक्षा

यहाँ चौराहे परीक्षण के लिए एक एल्गोरिथ्म (C #) है:

bool PointIsInGeometry(PointCollection points, MapPoint point)
{
int i;
int j = points.Count - 1;
bool output = false;

for (i = 0; i < points.Count; i++)
{
    if (points[i].X < point.X && points[j].X >= point.X || points[j].X < point.X && points[i].X >= point.X)
    {
        if (points[i].Y + (point.X - points[i].X) / (points[j].X - points[i].X) * (points[j].Y - points[i].Y) < point.Y)
        {
            output = !output;
        }
    }
    j = i;
}
return output;
}

10

वहाँ से बाहर कुछ अच्छे पुस्तकालय हैं जो आपके लिए अधिकांश भारी उठाने का काम करते हैं।

अजगर में [सुडौल] [1] का उपयोग कर उदाहरण।

import random
from shapely.geometry import Polygon, Point

def get_random_point_in_polygon(poly):
     minx, miny, maxx, maxy = poly.bounds
     while True:
         p = Point(random.uniform(minx, maxx), random.uniform(miny, maxy))
         if poly.contains(p):
             return p

p = Polygon([(0, 0), (0, 2), (1, 1), (2, 2), (2, 0), (1, 1), (0, 0)])
point_in_poly = get_random_point_in_polygon(mypoly)

या .representative_point()वस्तु के भीतर एक बिंदु प्राप्त करने के लिए उपयोग करें (जैसा कि उल्लेख किया गया है):

एक सस्ते गणना वाले बिंदु को लौटाता है जो कि ज्यामितीय वस्तु के भीतर होने की गारंटी है।

poly.representative_point().wkt
'POINT (-1.5000000000000000 0.0000000000000000)'

  [1]: https://shapely.readthedocs.io

2
क्या यह सुडौल.आग्रामी आयात से नहीं होना चाहिए ...?
पय्यमप्रा

1
आप इस representative_pointविधि का भी उपयोग कर सकते हैं : सुडौल.डरथेड्स .io
dain

6

यदि R एक विकल्प है, ?spsampleतो spपैकेज में देखें । बहुभुज को किसी भी GDAL- समर्थित प्रारूप से रग्दल पैकेज में बनाया गया है, और फिर spsampleविभिन्न प्रकार के नमूने विकल्पों के साथ सीधे आयातित वस्तु पर काम किया जा सकता है।


+1 - चूँकि R एक खुला स्रोत है यदि कोई प्रतिकृति बनाना चाहता है तो आप हमेशा स्रोत में जा कर देख सकते हैं कि वे कैसे किए जाते हैं। बिंदु पैटर्न के लिए स्पैटस्टैट पैकेज में सिमुलेशन टूल में भी रुचि हो सकती है।
एंडी डब्ल्यू

5

मैं एक ऐसे समाधान की पेशकश करना चाहूंगा जिसमें जीआईएस विश्लेषण के संदर्भ में बहुत कम आवश्यकता हो। विशेष रूप से, इसे किसी भी बहुभुज को त्रिभुज बनाने की आवश्यकता नहीं होती है।

निम्नलिखित एल्गोरिथ्म, स्यूडोकोड में दिया गया है, बुनियादी सूची हैंडलिंग क्षमताओं के अलावा कुछ सरल कार्यों को संदर्भित करता है (अंतराल, 0, 1) में यादृच्छिक फ्लोट की पीढ़ी (निर्माण, लंबाई, परिशिष्ट, सॉर्ट, एक्सट्रैक्ट सब्लिस्ट्स, और कॉन्कैटनेट) और जनरेट करें।

Area:        Return the area of a polygon (0 for an empty polygon).
BoundingBox: Return the bounding box (extent) of a polygon.
Width:       Return the width of a rectangle.
Height:      Return the height of a rectangle.
Left:        Split a rectangle into two halves and return the left half.
Right:       ... returning the right half.
Top:         ... returning the top half.
Bottom:      ... returning the bottom half.
Clip:        Clip a polygon to a rectangle.
RandomPoint: Return a random point in a rectangle.
Search:      Search a sorted list for a target value.  Return the index  
             of the last element less than the target.
In:          Test whether a point is inside a polygon.

ये सभी लगभग किसी भी जीआईएस या ग्राफिक्स प्रोग्रामिंग वातावरण में उपलब्ध हैं (और यदि नहीं तो कोड करना आसान है)। Clipपतित बहुभुजों (जो शून्य क्षेत्र वाले हैं) को वापस नहीं करना चाहिए।

प्रक्रिया SimpleRandomSampleकुशलता से बहुभुज के भीतर बेतरतीब ढंग से वितरित अंकों की एक सूची प्राप्त करती है। यह एक रैपर है SRS, जो बहुभुज को छोटे टुकड़ों में तोड़ता है जब तक कि प्रत्येक टुकड़ा कुशलता से नमूना लेने के लिए पर्याप्त रूप से कॉम्पैक्ट न हो। ऐसा करने के लिए, यह प्रत्येक टुकड़े को आवंटित करने के लिए कितने अंक तय करने के लिए यादृच्छिक संख्याओं की एक पूर्वनिर्मित सूची का उपयोग करता है।

एसआरएस को पैरामीटर बदलकर "ट्यून" किया जा सकता है t। यह अधिकतम बाउंडिंग बॉक्स है: बहुभुज क्षेत्र अनुपात जिसे सहन किया जा सकता है। इसे छोटा (लेकिन 1 से अधिक) बनाने से अधिकांश बहुभुज कई टुकड़ों में विभाजित हो जाएंगे; इसे बड़ा करने से कई पॉलीगोन (पापी, स्लेवर्स या छिद्रों से भरा) के लिए कई परीक्षण बिंदुओं को अस्वीकार किया जा सकता है। यह गारंटी देता है कि मूल बहुभुज के नमूने का अधिकतम समय अनुमानित है।

Procedure SimpleRandomSample(P:Polygon, N:Integer) {
    U = Sorted list of N independent uniform values between 0 and 1
    Return SRS(P, BoundingBox(P), U)
}

यदि आवश्यक हो तो अगली प्रक्रिया खुद को पुनरावर्ती कहती है। रहस्यमय अभिव्यक्ति का t*N + 5*Sqrt(t*N)रूढ़िवादी रूप से परिवर्तनशीलता के लिए लेखांकन, कितने बिंदुओं की आवश्यकता होगी, इस पर एक ऊपरी सीमा का अनुमान है। संभावना है कि यह विफल हो जाएगा केवल 0.3 प्रति मिलियन प्रक्रिया कॉल है। यदि आप चाहें तो इस संभावना को कम करने के लिए 5 से 6 या 7 तक बढ़ाएं।

Procedure SRS(P:Polygon, B:Rectangle, U:List) {
    N = Length(U)
    If (N == 0) {Return empty list}
    aP = Area(P)
    If (aP <= 0) {
        Error("Cannot sample degenerate polygons.")
        Return empty list
    }
    t = 2
    If (aP*t < Area(B)) {
        # Cut P into pieces
        If (Width(B) > Height(B)) {
            B1 = Left(B); B2 = Right(B)
        } Else {
            B1 = Bottom(B); B2 = Top(B)
        }
        P1 = Clip(P, B1); P2 = Clip(P, B2)
        K = Search(U, Area(P1) / aP)
        V = Concatenate( SRS(P1, B1, U[1::K]), SRS(P2, B2, U[K+1::N]) )
    } Else {
        # Sample P
        V = empty list
        maxIter = t*N + 5*Sqrt(t*N)
        While(Length(V) < N and maxIter > 0) {
            Decrement maxIter
            Q = RandomPoint(B)
            If (Q In P) {Append Q to V}
        }
       If (Length(V) < N) {
            Error("Too many iterations.")
       }
    }
    Return V
}

2

यदि आपका बहुभुज उत्तल है और आप सभी लम्बों को जानते हैं, तो आप एक नए बिंदु का नमूना करने के लिए कोने के "यादृच्छिक" उत्तल भार को करने पर विचार कर सकते हैं जो उत्तल पतवार (इस मामले में बहुभुज) के अंदर झूठ बोलने की गारंटी है।

उदाहरण के लिए, आपके पास एक N पक्षीय उत्तल बहुभुज है जिसमें कोने हैं

V_i, i={1,..,N}

फिर बेतरतीब ढंग से एन उत्तल वजन पैदा करते हैं

 w_1,w_2,..,w_N such that  w_i = 1; w_i>=0

फिर बेतरतीब ढंग से नमूना बिंदु द्वारा दिया जाता है

Y=  w_i*V_i

एन उत्तल वज़न के नमूने के लिए अलग-अलग तरीके हो सकते हैं

  • समान रूप से किसी श्रेणी (प्रतिस्थापन के बिना) के भीतर समान रूप से अनियमित रूप से एन -1 नंबर चुनें, उन्हें क्रमबद्ध करें और वजन प्राप्त करने के लिए उनके बीच एन अंतराल को सामान्य करें।
  • आप ड्यूरिचलेट वितरण से भी नमूना ले सकते हैं, जिसका उपयोग बहुराष्ट्रीय वितरण से पहले अक्सर संयुग्म के रूप में किया जाता है, जो आपके मामले में उत्तल भार के समान है।

जब आपका बहुभुज बहुत गंभीर रूप से गैर-उत्तल नहीं होता है, तो आप पहले इसे उत्तल पतवार में परिवर्तित करने पर विचार कर सकते हैं। यह कम से कम आपके बहुभुज के बाहर झूठ बोलने वाले बिंदुओं की संख्या को काफी हद तक सीमित कर देना चाहिए।


2

यह कार्य जीआरआईएस (एक कमांड) में v.random का उपयोग करके हल करना बहुत आसान है ।

मैनुअल पेज से चयनित पॉलीगोन (यहां रैले, एनसी शहर के ज़िप कोड क्षेत्र) में 3 यादृच्छिक बिंदुओं को जोड़ने के बारे में एक उदाहरण के नीचे। SQL को संशोधित करके "जहाँ" स्टेटमेंट बहुभुज को चुना जा सकता है।

चयनित बहुभुज में यादृच्छिक अंक उत्पन्न करना


1
ऑब्ज़र्गेटरी रिमाइंडर कि ज़िप कोड लाइनें हैं, पॉलीगॉन नहीं।
रिचर्ड

क्या आप विस्तार से समझा सकते हैं? मेरे लिए यहां भी यह क्षेत्रों को संदर्भित करता है: en.wikipedia.org/wiki/ZIP_Code#Primary_state_prefixes
markusN

ज़रूर: ज़िप कोड विशेष डाकघरों और उनके मेल वितरण मार्गों का संदर्भ देते हैं। नतीजतन, ज़िप कोड लाइनें हैं, बहुभुज नहीं। वे एक दूसरे के साथ ओवरलैप कर सकते हैं, छेद कर सकते हैं, और जरूरी नहीं कि पूरे यूएस या किसी भी दिए गए राज्य को कवर करें। क्षेत्र को विभाजित करने के लिए उनका उपयोग करना इस कारण से खतरनाक है। जनगणना इकाइयाँ (जैसे ब्लॉक समूह) एक बेहतर विकल्प हैं। यह भी देखें: इस और इस
रिचर्ड

1
धन्यवाद! यह शायद देश पर भी निर्भर करता है, उदाहरण के लिए देखें en.wikipedia.org/wiki/Postal_codes_in_Germany - हालांकि, ज़िप कोड मेरा मुख्य विषय नहीं हैं, बस मूल प्रश्न "मूल अंक जो बहुभुज के अंदर झूठ बोलते हैं" का वर्णन और उत्तर देना चाहते थे। ज़िप कोड परिभाषाओं पर चर्चा करें जो यहाँ ओटी है :-)
चिह्न

1
दोनों गणनाओं पर ध्यान दिया गया। मुझे शायद थोड़ा सा ब्लॉग प्रविष्टि करना चाहिए ताकि मैं अगली बार यह सब अधिक आसानी से कह
रिचर्ड

1

उत्तर लिंक

https://gis.stackexchange.com/a/307204/103524

विभिन्न तरीकों का उपयोग करते हुए तीन एल्गोरिदम।

Git रेपो लिंक

  1. यहां x और y दिशा से निर्देशांक की वास्तविक दूरी का उपयोग करते हुए एक सरल और सर्वोत्तम तरीका है। आंतरिक एल्गोरिथ्म WGS 1984 (4326) का उपयोग करता है और परिणामस्वरूप SRID सम्मिलित करता है।

समारोह ================================================================ ==================

CREATE OR REPLACE FUNCTION public.I_Grid_Point_Distance(geom public.geometry, x_side decimal, y_side decimal)
RETURNS public.geometry AS $BODY$
DECLARE
x_min decimal;
x_max decimal;
y_max decimal;
x decimal;
y decimal;
returnGeom public.geometry[];
i integer := -1;
srid integer := 4326;
input_srid integer;
BEGIN
CASE st_srid(geom) WHEN 0 THEN
    geom := ST_SetSRID(geom, srid);
        ----RAISE NOTICE 'No SRID Found.';
    ELSE
        ----RAISE NOTICE 'SRID Found.';
END CASE;
    input_srid:=st_srid(geom);
    geom := st_transform(geom, srid);
    x_min := ST_XMin(geom);
    x_max := ST_XMax(geom);
    y_max := ST_YMax(geom);
    y := ST_YMin(geom);
    x := x_min;
    i := i + 1;
    returnGeom[i] := st_setsrid(ST_MakePoint(x, y), srid);
<<yloop>>
LOOP
IF (y > y_max) THEN
    EXIT;
END IF;

CASE i WHEN 0 THEN 
    y := ST_Y(returnGeom[0]);
ELSE 
    y := ST_Y(ST_Project(st_setsrid(ST_MakePoint(x, y), srid), y_side, radians(0))::geometry);
END CASE;

x := x_min;
<<xloop>>
LOOP
  IF (x > x_max) THEN
      EXIT;
  END IF;
    i := i + 1;
    returnGeom[i] := st_setsrid(ST_MakePoint(x, y), srid);
    x := ST_X(ST_Project(st_setsrid(ST_MakePoint(x, y), srid), x_side, radians(90))::geometry);
END LOOP xloop;
END LOOP yloop;
RETURN
ST_CollectionExtract(st_transform(ST_Intersection(st_collect(returnGeom), geom), input_srid), 1);
END;
$BODY$ LANGUAGE plpgsql IMMUTABLE;

एक साधारण क्वेरी के साथ फ़ंक्शन का उपयोग करें, ज्यामिति वैध और बहुभुज, बहु-बहुभुज या लिफाफा होना चाहिए

SELECT I_Grid_Point_Distance(geom, 50, 61) from polygons limit 1;

परिणाम ================================================= ===================== यहां छवि विवरण दर्ज करें

  1. निकल्स एवन एल्गोरिथ्म पर आधारित दूसरा समारोह । किसी भी SRID को संभालने की कोशिश की है।

    मैंने एल्गोरिथ्म में निम्नलिखित परिवर्तनों को लागू किया है।

    1. पिक्सेल आकार के लिए x और y दिशा के लिए अलग चर,
    2. नया चर गोलाकार या दीर्घवृत्त में दूरी की गणना करता है।
    3. किसी भी SRID को इनपुट करें, फ़ंक्शन को गोलाकार या एलीपोसिड डेटम के काम के माहौल में परिवर्तित करें, फिर प्रत्येक पक्ष पर दूरी लागू करें, परिणाम प्राप्त करें और इनपुट SRID में परिवर्तित करें।

समारोह ================================================================ ==================

CREATE OR REPLACE FUNCTION I_Grid_Point(geom geometry, x_side decimal, y_side decimal, spheroid boolean default false)
RETURNS SETOF geometry AS $BODY$ 
DECLARE
x_max decimal; 
y_max decimal;
x_min decimal;
y_min decimal;
srid integer := 4326;
input_srid integer; 
BEGIN
CASE st_srid(geom) WHEN 0 THEN
  geom := ST_SetSRID(geom, srid);
  RAISE NOTICE 'SRID Not Found.';
    ELSE
        RAISE NOTICE 'SRID Found.';
    END CASE;

    CASE spheroid WHEN false THEN
        RAISE NOTICE 'Spheroid False';
        srid := 4326;
        x_side := x_side / 100000;
        y_side := y_side / 100000;
    else
        srid := 900913;
        RAISE NOTICE 'Spheroid True';
    END CASE;
    input_srid:=st_srid(geom);
    geom := st_transform(geom, srid);
    x_max := ST_XMax(geom);
    y_max := ST_YMax(geom);
    x_min := ST_XMin(geom);
    y_min := ST_YMin(geom);
RETURN QUERY
WITH res as (SELECT ST_SetSRID(ST_MakePoint(x, y), srid) point FROM
generate_series(x_min, x_max, x_side) as x,
generate_series(y_min, y_max, y_side) as y
WHERE st_intersects(geom, ST_SetSRID(ST_MakePoint(x, y), srid))
) select ST_TRANSFORM(ST_COLLECT(point), input_srid) from res;
END;
$BODY$ LANGUAGE plpgsql IMMUTABLE STRICT;

एक साधारण क्वेरी के साथ इसका उपयोग करें।

SELECT I_Grid_Point(geom, 22, 15, false) from polygons;

परिणाम ================================================= ==================यहां छवि विवरण दर्ज करें

  1. श्रृंखला जनरेटर पर आधारित कार्य।

समारोह ================================================= =================

CREATE OR REPLACE FUNCTION I_Grid_Point_Series(geom geometry, x_side decimal, y_side decimal, spheroid boolean default false)
RETURNS SETOF geometry AS $BODY$
DECLARE
x_max decimal;
y_max decimal;
x_min decimal;
y_min decimal;
srid integer := 4326;
input_srid integer;
x_series DECIMAL;
y_series DECIMAL;
BEGIN
CASE st_srid(geom) WHEN 0 THEN
  geom := ST_SetSRID(geom, srid);
  RAISE NOTICE 'SRID Not Found.';
    ELSE
        RAISE NOTICE 'SRID Found.';
    END CASE;

    CASE spheroid WHEN false THEN
        RAISE NOTICE 'Spheroid False';
    else
        srid := 900913;
        RAISE NOTICE 'Spheroid True';
    END CASE;
    input_srid:=st_srid(geom);
    geom := st_transform(geom, srid);
    x_max := ST_XMax(geom);
    y_max := ST_YMax(geom);
    x_min := ST_XMin(geom);
    y_min := ST_YMin(geom);

    x_series := CEIL ( @( x_max - x_min ) / x_side);
    y_series := CEIL ( @( y_max - y_min ) / y_side );
RETURN QUERY
SELECT st_collect(st_setsrid(ST_MakePoint(x * x_side + x_min, y*y_side + y_min), srid)) FROM
generate_series(0, x_series) as x,
generate_series(0, y_series) as y
WHERE st_intersects(st_setsrid(ST_MakePoint(x*x_side + x_min, y*y_side + y_min), srid), geom);
END;
$BODY$ LANGUAGE plpgsql IMMUTABLE STRICT;

एक साधारण क्वेरी के साथ इसका उपयोग करें।

SELECT I_Grid_Point_Series(geom, 22, 15, false) from polygons; परिणाम ================================================= =========================

यहां छवि विवरण दर्ज करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.