সম্ভবত এটির জন্য কোনও জিআইএস প্ল্যাটফর্মের কিছু স্ক্রিপ্টিং দরকার।
সর্বাধিক দক্ষ পদ্ধতিটি (অ্যাসিপটোটিক্যালি) একটি উল্লম্ব লাইন সুইপ: এটি ও (ই * লগ) এর জন্য প্রান্তগুলি তাদের ন্যূনতম y- স্থানাঙ্কগুলি অনুসারে বাছাই করা এবং তারপরে নীচে (সর্বনিম্ন y) শীর্ষে (সর্বোচ্চ y) প্রান্তগুলি প্রক্রিয়াকরণ করা প্রয়োজন it e)) ই প্রান্তগুলি জড়িত থাকার সময় অ্যালগরিদম ।
পদ্ধতিটি যদিও সহজ, তবুও সব ক্ষেত্রেই সঠিকভাবে আশ্চর্যজনকভাবে জটিল। বহুভুজগুলি অদ্ভুত হতে পারে: এগুলির ড্যাঙ্গেলস, স্লিভারস, গর্ত, সংযোগ বিচ্ছিন্ন হতে পারে, সদৃশ রেখা বরাবর উল্লম্ব কোণগুলি থাকতে পারে এবং দুটি সংলগ্ন উপাদানগুলির মধ্যে অমীমাংসিত সীমানা থাকতে পারে। এই বৈশিষ্ট্যগুলির (এবং আরও অনেক) অনেকগুলি প্রদর্শিত এখানে একটি উদাহরণ রয়েছে:
আমরা বিশেষভাবে বহুভুজটির বন্ধের মধ্যে থাকা পুরো দৈর্ঘ্যের অনুভূমিক অংশটি সন্ধান করব । উদাহরণস্বরূপ, এটি 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), তালিকায় অন্তর্ভুক্ত নয় ।
অভ্যন্তরীণ পয়েন্টগুলি কোথায় এবং বাহ্যিক দিকগুলি নির্ধারণ করার জন্য, চূড়ান্ত বাম থেকে শুরু করে কল্পনা করুন - যা অবশ্যই বহুভুজের বাইরে রয়েছে - এবং অনুভূমিকভাবে ডানদিকে সরানো। প্রতিবার আমরা একটি প্রান্ত অতিক্রম করব যা অনুভূমিক নয় , আমরা পর্যায়ক্রমে বাহ্যিক থেকে অভ্যন্তর এবং পিছনে স্যুইচ করি। (এটি অন্য একটি মূল ধারণা)) তবে যে কোনও অনুভূমিক প্রান্তের সমস্ত পয়েন্টগুলি বহুভুজের অভ্যন্তরেই নির্ধারিত হয়, যাই হোক না কেন। (বহুভুজটি বন্ধ হওয়ার সাথে সর্বদা এর প্রান্তগুলি অন্তর্ভুক্ত থাকে))
উদাহরণস্বরূপ, এখানে এক্স-স্থানাঙ্কের বাছাই করা তালিকা দেওয়া হয়েছে যেখানে অনুভূমিক প্রান্তগুলি 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 এর মধ্যবর্তীটি বহুভুজের বাইরে রয়েছে indicates এবং তাই এটি এগিয়ে যায়: অ্যারে বহুভুজের অভ্যন্তরের হিসাবে চারটি পৃথক অন্তর চিহ্নিত করে।
এর মধ্যে কয়েকটি অন্তর, যেমন x = 60 থেকে x = 63.3 এর মধ্যে কোনও বিন্দু ছেদ করে না: y = 10 দিয়ে সমস্ত উলম্বের এক্স-স্থানাঙ্কের বিরুদ্ধে একটি দ্রুত চেক যেমন অন্তরগুলি সরিয়ে দেয়।
স্ক্যান চলাকালীন আমরা এই ব্যবধানগুলির দৈর্ঘ্য পর্যবেক্ষণ করতে পারি, এখন পর্যন্ত পাওয়া সর্বাধিক দৈর্ঘ্যের বিরতি সম্পর্কিত ডেটা ধরে রেখে।
এই পদ্ধতির কিছু নিদর্শন লক্ষ্য করুন। একটি "ভি" আকারের ভার্টেক্স, যখন মুখোমুখি হয়, তখন দুটি প্রান্তের উত্স। সুতরাং এটি অতিক্রম করার সময় দুটি সুইচ ঘটে। সেই সুইচগুলি বাতিল হয়ে গেছে। যে কোনও উত্স-ডাউন "ভি" এমনকি প্রক্রিয়াজাত হয় না, কারণ এর দুটি প্রান্ত বাম থেকে ডান স্ক্যান শুরু করার আগেই মুছে ফেলা হয়। উভয় ক্ষেত্রেই, এই জাতীয় একটি অনুভূমিক অংশটি বন্ধ করে দেয় না।
দুটিরও বেশি প্রান্ত একটি শিরোনাম ভাগ করতে পারে: এটি (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
এর ফলে x = 30 এর বামে সমস্ত কিছু বাহ্যিক হিসাবে বিবেচিত হবে, 30 থেকে 50 এর মধ্যে সমস্ত কিছু অভ্যন্তরীণ হবে এবং 50 এর পরে সমস্ত কিছু আবার বহিরাগত হবে। X = 40 এর শীর্ষবিন্দু এমনকি এই অ্যালগরিদমে কখনও বিবেচনা করা হয় না।
স্ক্যানের শেষে বহুভুজ দেখতে কেমন। আমি গা ver় ধূসর মধ্যে সমস্ত শীর্ষবিন্দুযুক্ত অভ্যন্তরীণ অন্তরগুলি দেখাব, লাল কোনও সর্বাধিক দৈর্ঘ্যের অন্তর, এবং তাদের y- স্থানাঙ্ক অনুযায়ী প্রান্তকে রঙ করুন। সর্বাধিক বিরতি 64 ইউনিট দীর্ঘ long
জড়িত কেবল জ্যামিতিক গণনাগুলিই এমন গণনা করা হয় যেখানে প্রান্তগুলি অনুভূমিক রেখাগুলি ছেদ করে: এটি একটি সাধারণ লিনিয়ার অন্তরঙ্গন। কোন অভ্যন্তরীণ বিভাগগুলিতে শৃঙ্খলা রয়েছে তা নির্ধারণের জন্য গণনাগুলিও প্রয়োজনীয় : এগুলি হ'ল দূরত্ব নির্ধারণ, সহজেই বেশ কয়েকটি অসমতার সাথে গণনা করা। এই সরলতাটি পূর্ণসংখ্যা এবং ভাসমান পয়েন্টের সমন্বয় উপস্থাপনের জন্য অ্যালগরিদমকে শক্ত এবং উপযুক্ত করে তোলে।
স্থানাঙ্কগুলি যদি ভৌগলিক হয় তবে অনুভূমিক রেখাগুলি অক্ষাংশের বৃত্তগুলিতে রয়েছে। তাদের দৈর্ঘ্য গণনা করা কঠিন নয়: কেবলমাত্র তাদের ইউক্লিডিয়ান দৈর্ঘ্যগুলি তাদের অক্ষাংশের কোসাইন দ্বারা (একটি গোলাকৃতির মডেলটিতে) গুণ করুন। অতএব এই অ্যালগরিদম ভৌগলিক স্থানাঙ্কে খুব ভালভাবে খাপ খায়। (+ -180 মেরিডিয়ান ভালভাবে চারপাশে মোড়ানো পরিচালনা করার জন্য প্রথমে দক্ষিণ মেরু থেকে উত্তর মেরুতে যে বহুবিন্দুটি অতিক্রম করে না এমন একটি বাঁক খুঁজে পাওয়া দরকার all সমস্ত এক্স-স্থানাঙ্কটিকে অনুভূমিক স্থানচ্যুতি হিসাবে পুনরায় প্রকাশের পরে বক্ররেখা, এই অ্যালগরিদম সঠিকভাবে সর্বাধিক অনুভূমিক অংশটি খুঁজে পাবে))
নিম্নলিখিত 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)
