इस संभावना को किसी भी जीआईएस प्लेटफॉर्म में कुछ स्क्रिप्टिंग की आवश्यकता होती है।
सबसे कुशल विधि (asymptotically) एक वर्टिकल लाइन स्वीप है: इसमें किनारों को उनके न्यूनतम y- निर्देशांक द्वारा छांटने और फिर किनारों को नीचे (न्यूनतम y) से ऊपर (अधिकतम y) तक संसाधित करने की आवश्यकता होती है, O (e * log) के लिए ई)) एल्गोरिथ्म जब ई किनारों शामिल हैं।
प्रक्रिया, हालांकि सरल है, सभी मामलों में सही पाने के लिए आश्चर्यजनक रूप से मुश्किल है। बहुभुज गंदे हो सकते हैं: उनके पास झूलने, स्लिवर्स, छेद हो सकते हैं, डिस्कनेक्ट हो सकते हैं, अनुलंब रेखाएं, सीधी रेखाओं के साथ रन होते हैं, और दो आसन्न घटकों के बीच असमान सीमाएं होती हैं। यहाँ इन विशेषताओं में से कई का प्रदर्शन एक उदाहरण है (और अधिक):
हम विशेष रूप से बहुभुज के बंद होने के भीतर अधिकतम लंबाई वाले क्षैतिज खंड (ओं) की तलाश करेंगे । उदाहरण के लिए, यह x = 20 और x = 40 के बीच के छिद्र को x = 10 और x = 25 के बीच के छिद्र से निकालता है। यह दिखाने के लिए सीधा है कि अधिकतम लंबाई वाले क्षैतिज खंडों में से कम से कम एक शीर्ष पर स्थित है। (यदि कोई कोने को काटते हुए समाधान नहीं हैं, तो वे समाधान द्वारा ऊपर और नीचे बंधे हुए कुछ समांतर चतुर्भुज के आंतरिक भाग में स्थित होंगे, जो कम से कम एक शीर्ष पर प्रतिच्छेद करते हैं । यह हमें सभी समाधान खोजने का साधन देता है ।)
तदनुसार, लाइन स्वीप को सबसे निचले कोने से शुरू करना चाहिए और फिर अपने शीर्ष पर रुकने के लिए ऊपर (यानी उच्च y मान की ओर) बढ़ना चाहिए। प्रत्येक पड़ाव में, हम किसी भी नए किनारों को उस ऊँचाई से ऊपर की ओर निकलते हुए पाते हैं; उस ऊंचाई पर नीचे से समाप्त होने वाले किसी भी किनारे को समाप्त करना (यह महत्वपूर्ण विचारों में से एक है: यह एल्गोरिथ्म को सरल करता है और संभावित प्रसंस्करण के आधे को समाप्त करता है); और सावधानी से किसी भी किनारों को पूरी तरह से एक निरंतर ऊंचाई (क्षैतिज किनारों) पर लेटने की प्रक्रिया करें।
उदाहरण के लिए, उस स्थिति पर विचार करें जब y = 10 का स्तर पहुंचता है। बाएं से दाएं, हम निम्नलिखित किनारों को पाते हैं:
x.min x.max y.min y.max
[1,] 10 0 0 30
[2,] 10 24 10 20
[3,] 20 24 10 20
[4,] 20 40 10 10
[5,] 40 20 10 10
[6,] 60 0 5 30
[7,] 60 60 5 30
[8,] 60 70 5 20
[9,] 60 70 5 15
[10,] 90 100 10 40
इस तालिका में, (x.min, y.min) किनारे के निचले छोर के निर्देशांक हैं और (x.max, y.max) इसके ऊपरी समापन बिंदु के निर्देशांक हैं। इस स्तर (y = 10) पर, पहले किनारे को इसके आंतरिक हिस्से के भीतर इंटरसेप्ट किया गया है, दूसरे को इसके तल पर इंटरसेप्ट किया गया है, और इसी तरह। इस स्तर पर समाप्त होने वाले कुछ किनारों, जैसे (10,0) से (10,10), सूची में शामिल नहीं हैं।
यह निर्धारित करने के लिए कि आंतरिक बिंदु कहां हैं और बाहरी वाले हैं, अत्यधिक बाएं से शुरू होने की कल्पना करें - जो बहुभुज के बाहर है, निश्चित रूप से - और क्षैतिज रूप से दाईं ओर बढ़ रहा है। हर बार जब हम एक किनारे को पार करते हैं जो क्षैतिज नहीं होता है , तो हम वैकल्पिक रूप से बाहरी से आंतरिक और वापस स्विच करते हैं। (यह एक और महत्वपूर्ण विचार है।) हालांकि, किसी भी क्षैतिज किनारे के भीतर सभी बिंदु बहुभुज के अंदर होने के लिए निर्धारित किए जाते हैं, चाहे कोई भी हो। (बहुभुज के बंद होने में हमेशा इसके किनारे शामिल होते हैं।)
उदाहरण को जारी रखते हुए, यहां x-निर्देशांक की क्रमबद्ध सूची है जहां गैर-क्षैतिज किनारों की शुरुआत होती है और y = 10 रेखा को पार करते हैं:
x.array 6.7 10 20 48 60 63.3 65 90
interior 1 0 1 0 1 0 1 0
(ध्यान दें कि x = 40 इस सूची में नहीं है।) interiorसरणी के मान आंतरिक खंडों के बाएं छोरों को चिह्नित करते हैं: 1 एक आंतरिक अंतराल, 0 एक बाहरी अंतराल नामित करता है। इस प्रकार, पहला 1 x = 6.7 से x = 10 तक अंतराल को इंगित करता है बहुभुज के अंदर। अगला 0 x = 10 से x = 20 के अंतराल को बहुभुज के बाहर दर्शाता है । और इसलिए यह आगे बढ़ता है: सरणी बहुभुज के अंदर चार अलग-अलग अंतराल की पहचान करती है।
इनमें से कुछ अंतराल, जैसे कि x = 60 से x = 63.3 तक, किसी भी कोने को नहीं काटते हैं: y = 10 के साथ सभी कोने के x- निर्देशांक के खिलाफ एक त्वरित जांच ऐसे अंतराल को समाप्त कर देती है।
स्कैन के दौरान हम इन अंतरालों की लंबाई की निगरानी कर सकते हैं, जो अब तक पाए गए अधिकतम-लंबाई अंतराल (ओं) से संबंधित डेटा को बनाए रखते हैं।
इस दृष्टिकोण के कुछ निहितार्थों पर ध्यान दें। एक "वी" आकार का शीर्ष, जब सामना किया जाता है, तो दो किनारों की उत्पत्ति होती है। इसलिए इसे पार करते समय दो स्विच होते हैं। वे स्विच रद्द हो जाते हैं। किसी भी उल्टा "वी" को भी संसाधित नहीं किया जाता है, क्योंकि इसके दोनों किनारों को बाएं से दाएं स्कैन शुरू करने से पहले समाप्त कर दिया जाता है। दोनों ही मामलों में, इस तरह के एक शीर्ष क्षैतिज खंड को बंद नहीं करता है।
दो से अधिक किनारों को एक शीर्ष साझा कर सकते हैं: यह (10,0), (60,5), (25, 20), और - (हालांकि, 20,10) और - (40 पर बताना कठिन है) , 10)। (ऐसा इसलिए है क्योंकि दंगल (20,10) -> (40,10) -> (40,0) -> (40, -50) -> (40, 10) -> (20) 10)। ध्यान दें कि कैसे (40,0) पर शीर्ष भी एक और किनारे के इंटीरियर में है ... यह बुरा है।) यह एल्गोरिथ्म उन स्थितियों को बस ठीक से संभालता है।
एक मुश्किल स्थिति को बहुत नीचे चित्रित किया गया है: गैर-क्षैतिज खंडों के एक्स-निर्देशांक हैं
30, 50
यह एक्स = 30 के बाईं ओर सब कुछ बाहरी माना जाता है, सब कुछ 30 और 50 के बीच आंतरिक होने के लिए, और 50 के बाद सब कुछ फिर से बाहरी होने के लिए। इस एल्गोरिथ्म में x = 40 पर वर्टेक्स को कभी भी नहीं माना जाता है।
यहाँ बहुभुज स्कैन के अंत में कैसा दिखता है। मैं सभी शीर्ष-युक्त आंतरिक अंतराल को ग्रे में दिखाता हूं, लाल रंग में किसी भी अधिकतम-लंबाई के अंतराल और उनके y- निर्देशांक के अनुसार कोने को रंग देता हूं। अधिकतम अंतराल 64 इकाइयों लंबा है।
इसमें शामिल केवल ज्यामितीय गणनाएं होती हैं, जहां किनारों को क्षैतिज रेखाओं को काटते हैं: यह एक सरल रैखिक प्रक्षेप है। गणना यह भी निर्धारित करने के लिए आवश्यक है कि कौन से आंतरिक खंडों में कोने हैं: ये समानता निर्धारण हैं, आसानी से असमानताओं के एक जोड़े के साथ गणना की जाती है। यह सादगी एल्गोरिदम को पूर्णांक और फ्लोटिंग पॉइंट समन्वय अभ्यावेदन दोनों के लिए मजबूत और उपयुक्त बनाती है।
यदि निर्देशांक भौगोलिक हैं , तो क्षैतिज रेखाएं अक्षांश के हलकों पर वास्तव में हैं। उनकी लंबाई की गणना करना मुश्किल नहीं है: बस उनके यूक्लिडियन लंबाई को उनके अक्षांश (एक गोलाकार मॉडल में) के कोसाइन से गुणा करें। इसलिए यह एल्गोरिदम भौगोलिक निर्देशांक के लिए अच्छी तरह से adapts। (+ -180 मेरिडियन कुएं के चारों ओर आवरण को संभालने के लिए, किसी को पहले दक्षिणी ध्रुव से उत्तरी ध्रुव तक एक वक्र खोजने की आवश्यकता हो सकती है जो बहुभुज से नहीं गुजरता है। सभी एक्स-निर्देशांक को क्षैतिज विस्थापन के रूप में फिर से व्यक्त करने के बाद। वक्र, इस एल्गोरिथ्म सही ढंग से अधिकतम क्षैतिज खंड मिल जाएगा।)
Rगणना करने और चित्र बनाने के लिए लागू कोड निम्नलिखित है ।
#
# Plotting functions.
#
points.polygon <- function(p, ...) {
points(p$v, ...)
}
plot.polygon <- function(p, ...) {
apply(p$e, 1, function(e) lines(matrix(e[c("x.min", "x.max", "y.min", "y.max")], ncol=2), ...))
}
expand <- function(bb, e=1) {
a <- matrix(c(e, 0, 0, e), ncol=2)
origin <- apply(bb, 2, mean)
delta <- origin %*% a - origin
t(apply(bb %*% a, 1, function(x) x - delta))
}
#
# Convert polygon to a better data structure.
#
# A polygon class has three attributes:
# v is an array of vertex coordinates "x" and "y" sorted by increasing y;
# e is an array of edges from (x.min, y.min) to (x.max, y.max) with y.max >= y.min, sorted by y.min;
# bb is its rectangular extent (x0,y0), (x1,y1).
#
as.polygon <- function(p) {
#
# p is a list of linestrings, each represented as a sequence of 2-vectors
# with coordinates in columns "x" and "y".
#
f <- function(p) {
g <- function(i) {
v <- p[(i-1):i, ]
v[order(v[, "y"]), ]
}
sapply(2:nrow(p), g)
}
vertices <- do.call(rbind, p)
edges <- t(do.call(cbind, lapply(p, f)))
colnames(edges) <- c("x.min", "x.max", "y.min", "y.max")
#
# Sort by y.min.
#
vertices <- vertices[order(vertices[, "y"]), ]
vertices <- vertices[!duplicated(vertices), ]
edges <- edges[order(edges[, "y.min"]), ]
# Maintaining an extent is useful.
bb <- apply(vertices <- vertices[, c("x","y")], 2, function(z) c(min(z), max(z)))
# Package the output.
l <- list(v=vertices, e=edges, bb=bb); class(l) <- "polygon"
l
}
#
# Compute the maximal horizontal interior segments of a polygon.
#
fetch.x <- function(p) {
#
# Update moves the line from the previous level to a new, higher level, changing the
# state to represent all edges originating or strictly passing through level `y`.
#
update <- function(y) {
if (y > state$level) {
state$level <<- y
#
# Remove edges below the new level from state$current.
#
current <- state$current
current <- current[current[, "y.max"] > y, ]
#
# Adjoin edges at this level.
#
i <- state$i
while (i <= nrow(p$e) && p$e[i, "y.min"] <= y) {
current <- rbind(current, p$e[i, ])
i <- i+1
}
state$i <<- i
#
# Sort the current edges by x-coordinate.
#
x.coord <- function(e, y) {
if (e["y.max"] > e["y.min"]) {
((y - e["y.min"]) * e["x.max"] + (e["y.max"] - y) * e["x.min"]) / (e["y.max"] - e["y.min"])
} else {
min(e["x.min"], e["x.max"])
}
}
if (length(current) > 0) {
x.array <- apply(current, 1, function(e) x.coord(e, y))
i.x <- order(x.array)
current <- current[i.x, ]
x.array <- x.array[i.x]
#
# Scan and mark each interval as interior or exterior.
#
status <- FALSE
interior <- numeric(length(x.array))
for (i in 1:length(x.array)) {
if (current[i, "y.max"] == y) {
interior[i] <- TRUE
} else {
status <- !status
interior[i] <- status
}
}
#
# Simplify the data structure by retaining the last value of `interior`
# within each group of common values of `x.array`.
#
interior <- sapply(split(interior, x.array), function(i) rev(i)[1])
x.array <- sapply(split(x.array, x.array), function(i) i[1])
print(y)
print(current)
print(rbind(x.array, interior))
markers <- c(1, diff(interior))
intervals <- x.array[markers != 0]
#
# Break into a list structure.
#
if (length(intervals) > 1) {
if (length(intervals) %% 2 == 1)
intervals <- intervals[-length(intervals)]
blocks <- 1:length(intervals) - 1
blocks <- blocks - (blocks %% 2)
intervals <- split(intervals, blocks)
} else {
intervals <- list()
}
} else {
intervals <- list()
}
#
# Update the state.
#
state$current <<- current
}
list(y=y, x=intervals)
} # Update()
process <- function(intervals, x, y) {
# intervals is a list of 2-vectors. Each represents the endpoints of
# an interior interval of a polygon.
# x is an array of x-coordinates of vertices.
#
# Retains only the intervals containing at least one vertex.
between <- function(i) {
1 == max(mapply(function(a,b) a && b, i[1] <= x, x <= i[2]))
}
is.good <- lapply(intervals$x, between)
list(y=y, x=intervals$x[unlist(is.good)])
#intervals
}
#
# Group the vertices by common y-coordinate.
#
vertices.x <- split(p$v[, "x"], p$v[, "y"])
vertices.y <- lapply(split(p$v[, "y"], p$v[, "y"]), max)
#
# The "state" is a collection of segments and an index into edges.
# It will updated during the vertical line sweep.
#
state <- list(level=-Inf, current=c(), i=1, x=c(), interior=c())
#
# Sweep vertically from bottom to top, processing the intersection
# as we go.
#
mapply(function(x,y) process(update(y), x, y), vertices.x, vertices.y)
}
scale <- 10
p.raw = list(scale * cbind(x=c(0:10,7,6,0), y=c(3,0,0,-1,-1,-1,0,-0.5,0.75,1,4,1.5,0.5,3)),
scale *cbind(x=c(1,1,2.4,2,4,4,4,4,2,1), y=c(0,1,2,1,1,0,-0.5,1,1,0)),
scale *cbind(x=c(6,7,6,6), y=c(.5,2,3,.5)))
#p.raw = list(cbind(x=c(0,2,1,1/2,0), y=c(0,0,2,1,0)))
#p.raw = list(cbind(x=c(0, 35, 100, 65, 0), y=c(0, 50, 100, 50, 0)))
p <- as.polygon(p.raw)
results <- fetch.x(p)
#
# Find the longest.
#
dx <- matrix(unlist(results["x", ]), nrow=2)
length.max <- max(dx[2,] - dx[1,])
#
# Draw pictures.
#
segment.plot <- function(s, length.max, colors, ...) {
lapply(s$x, function(x) {
col <- ifelse (diff(x) >= length.max, colors[1], colors[2])
lines(x, rep(s$y,2), col=col, ...)
})
}
gray <- "#f0f0f0"
grayer <- "#d0d0d0"
plot(expand(p$bb, 1.1), type="n", xlab="x", ylab="y", main="After the Scan")
sapply(1:length(p.raw), function(i) polygon(p.raw[[i]], col=c(gray, "White", grayer)[i]))
apply(results, 2, function(s) segment.plot(s, length.max, colors=c("Red", "#b8b8a8"), lwd=4))
plot(p, col="Black", lty=3)
points(p, pch=19, col=round(2 + 2*p$v[, "y"]/scale, 0))
points(p, cex=1.25)
