สำหรับกราฟิกฉันไม่ชอบจำนวนเต็ม ระบบจำนวนมากใช้จำนวนเต็มสำหรับการวาด UI (พิกเซลเป็น ints ทั้งหมด) แต่ macOS เช่นใช้การลอยสำหรับทุกสิ่ง macOS รู้จุดเท่านั้นและจุดหนึ่งสามารถแปลเป็นหนึ่งพิกเซลได้ แต่ขึ้นอยู่กับความละเอียดของจอภาพมันอาจแปลเป็นอย่างอื่น บนหน้าจอเรตินาครึ่งจุด (0.5 / 0.5) คือพิกเซล ถึงกระนั้นฉันไม่เคยสังเกตว่า macOS UIs ช้ากว่า UIs อื่น ๆ อย่างมีนัยสำคัญ หลังจาก 3D APIs ทั้งหมด (OpenGL หรือ Direct3D) ยังทำงานร่วมกับการลอยและไลบรารีกราฟิกที่ทันสมัยมักใช้ประโยชน์จากการเร่งความเร็วของ GPU
ตอนนี้คุณพูดว่าความเร็วเป็นสิ่งที่คุณกังวลเป็นหลักเอาล่ะเร่งความเร็วกันเถอะ ก่อนที่คุณจะรันอัลกอริทึมที่ซับซ้อนก่อนอื่นให้ทำการทดสอบอย่างง่าย สร้างกล่องที่มีการจัดแนวแกนรอบรูปหลายเหลี่ยมของคุณ นี่เป็นเรื่องง่ายรวดเร็วและสามารถทำให้คุณปลอดภัยจากการคำนวณมากมาย มันทำงานอย่างไร วนซ้ำทุกจุดของรูปหลายเหลี่ยมและหาค่าต่ำสุด / สูงสุดของ X และ Y
(9/1), (4/3), (2/7), (8/2), (3/6)เช่นคุณมีจุด ซึ่งหมายความว่า Xmin คือ 2, Xmax คือ 9, Ymin คือ 1 และ Ymax คือ 7 จุดนอกสี่เหลี่ยมที่มีขอบทั้งสอง (2/1) และ (9/7) ไม่สามารถอยู่ในรูปหลายเหลี่ยมได้
// p is your point, p.x is the x coord, p.y is the y coord
if (p.x < Xmin || p.x > Xmax || p.y < Ymin || p.y > Ymax) {
// Definitely not within the polygon!
}
นี่คือการทดสอบครั้งแรกเพื่อให้ทำงานได้ทุกจุด อย่างที่คุณเห็นการทดสอบนี้เร็วมาก แต่ก็ค่อนข้างหยาบ ในการจัดการกับจุดที่อยู่ในขอบเขตสี่เหลี่ยมผืนผ้าเราจำเป็นต้องมีอัลกอริทึมที่ซับซ้อนมากขึ้น มีสองวิธีในการคำนวณสิ่งนี้ วิธีใดที่ใช้งานได้ขึ้นอยู่กับความจริงถ้ารูปหลายเหลี่ยมสามารถมีรูหรือจะเป็นของแข็งเสมอ นี่คือตัวอย่างของของแข็ง (หนึ่งนูนหนึ่งเว้า):
และนี่คืออันที่มีรู:
สีเขียวมีรูตรงกลาง!
ขั้นตอนวิธีการที่ง่ายที่สุดที่สามารถจัดการกับทั้งสามกรณีข้างต้นและยังคงสวยได้อย่างรวดเร็วเป็นชื่อเรย์หล่อ แนวคิดของอัลกอริธึมนั้นค่อนข้างง่าย: วาดเรย์เสมือนจากที่ใดก็ได้นอกรูปหลายเหลี่ยมไปยังจุดของคุณและนับความถี่ที่มันกระทบด้านข้างของรูปหลายเหลี่ยม หากจำนวนการเข้าชมเป็นเลขคู่มันอยู่นอกรูปหลายเหลี่ยมถ้าเป็นเลขคี่ก็จะอยู่ข้างใน
อัลกอริทึมจำนวนขดลวดจะเป็นทางเลือกที่ถูกต้องมากขึ้นสำหรับจุดที่เป็นมากใกล้เคียงกับเส้นรูปหลายเหลี่ยม แต่ก็ยังช้ามาก การหล่อเรย์อาจล้มเหลวสำหรับจุดที่อยู่ใกล้กับด้านรูปหลายเหลี่ยมมากเกินไปเนื่องจากความแม่นยำของจุดลอยตัวที่ จำกัด และปัญหาการปัดเศษ แต่ในความเป็นจริงที่แทบจะไม่เป็นปัญหาราวกับว่าจุดนั้นอยู่ใกล้กับด้านข้าง ผู้ชมที่จะรับรู้ว่ามันมีอยู่แล้วภายในหรือภายนอก
คุณยังมีกล่องของขอบเขตด้านบนจำได้ไหม เพียงแค่เลือกจุดนอกกรอบและใช้เป็นจุดเริ่มต้นสำหรับรังสีของคุณ เช่นจุด(Xmin - e/p.y)อยู่นอกรูปหลายเหลี่ยมได้อย่างแน่นอน
แต่สิ่งที่เป็นe? เอาล่ะe(จริง ๆ เอปไซลอน) ให้ช่องว่างภายใน อย่างที่ฉันพูดการติดตามเรย์ล้มเหลวถ้าเราเริ่มเข้าใกล้เส้นรูปหลายเหลี่ยมมากเกินไป เนื่องจากกล่องขอบอาจเท่ากับรูปหลายเหลี่ยม (ถ้ารูปหลายเหลี่ยมนั้นเป็นรูปสี่เหลี่ยมผืนผ้าที่จัดแนวแกนกล่องที่มีรูปทรงเท่ากับรูปหลายเหลี่ยมตัวเอง!) เราจึงต้องใช้ช่องว่างภายในเพื่อให้เกิดความปลอดภัยนั่นคือทั้งหมด คุณควรเลือกขนาดeไหน ไม่ใหญ่เกินไป ขึ้นอยู่กับขนาดของระบบพิกัดที่คุณใช้สำหรับการวาด หากความกว้างพิกเซลของคุณเป็น 1.0 ให้เลือก 1.0 (แต่ 0.1 ก็ใช้ได้เช่นกัน)
ตอนนี้เรามีรังสีพร้อมพิกัดเริ่มต้นและจุดสิ้นสุดปัญหาการเลื่อนจาก " คือจุดที่อยู่ภายในรูปหลายเหลี่ยม " เป็น " ความถี่ที่รังสีตัดกับด้านรูปหลายเหลี่ยม " ดังนั้นเราจึงไม่สามารถทำงานกับคะแนนรูปหลายเหลี่ยมเหมือนก่อนตอนนี้เราต้องการด้านที่แท้จริง ด้านถูกกำหนดโดยจุดสองจุดเสมอ
side 1: (X1/Y1)-(X2/Y2)
side 2: (X2/Y2)-(X3/Y3)
side 3: (X3/Y3)-(X4/Y4)
:
คุณต้องทดสอบรังสีกับทุกด้าน พิจารณารังสีให้เป็นเวกเตอร์และทุก ๆ ด้านเป็นเวกเตอร์ รังสีจะกระทบแต่ละด้านอย่างแน่นอนหรือไม่เคยเลย มันไม่สามารถชนด้านเดียวกันสองครั้ง เส้นสองเส้นในพื้นที่ 2 มิติจะตัดกันหนึ่งครั้งเสมอเว้นแต่จะขนานกันซึ่งในกรณีนี้พวกเขาไม่เคยตัดกัน อย่างไรก็ตามเนื่องจากเวกเตอร์มีความยาว จำกัด เวกเตอร์สองตัวอาจไม่ขนานกันและยังไม่เคยตัดกันเพราะมันสั้นเกินไปที่จะเจอกัน
// Test the ray against all sides
int intersections = 0;
for (side = 0; side < numberOfSides; side++) {
// Test if current side intersects with ray.
// If yes, intersections++;
}
if ((intersections & 1) == 1) {
// Inside of polygon
} else {
// Outside of polygon
}
จนถึงตอนนี้ แต่คุณจะทดสอบว่าเวกเตอร์สองตัวตัดกันได้อย่างไร นี่คือรหัส C (ไม่ผ่านการทดสอบ) ที่ควรทำเคล็ดลับ:
#define NO 0
#define YES 1
#define COLLINEAR 2
int areIntersecting(
float v1x1, float v1y1, float v1x2, float v1y2,
float v2x1, float v2y1, float v2x2, float v2y2
) {
float d1, d2;
float a1, a2, b1, b2, c1, c2;
// Convert vector 1 to a line (line 1) of infinite length.
// We want the line in linear equation standard form: A*x + B*y + C = 0
// See: http://en.wikipedia.org/wiki/Linear_equation
a1 = v1y2 - v1y1;
b1 = v1x1 - v1x2;
c1 = (v1x2 * v1y1) - (v1x1 * v1y2);
// Every point (x,y), that solves the equation above, is on the line,
// every point that does not solve it, is not. The equation will have a
// positive result if it is on one side of the line and a negative one
// if is on the other side of it. We insert (x1,y1) and (x2,y2) of vector
// 2 into the equation above.
d1 = (a1 * v2x1) + (b1 * v2y1) + c1;
d2 = (a1 * v2x2) + (b1 * v2y2) + c1;
// If d1 and d2 both have the same sign, they are both on the same side
// of our line 1 and in that case no intersection is possible. Careful,
// 0 is a special case, that's why we don't test ">=" and "<=",
// but "<" and ">".
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// The fact that vector 2 intersected the infinite line 1 above doesn't
// mean it also intersects the vector 1. Vector 1 is only a subset of that
// infinite line 1, so it may have intersected that line before the vector
// started or after it ended. To know for sure, we have to repeat the
// the same test the other way round. We start by calculating the
// infinite line 2 in linear equation standard form.
a2 = v2y2 - v2y1;
b2 = v2x1 - v2x2;
c2 = (v2x2 * v2y1) - (v2x1 * v2y2);
// Calculate d1 and d2 again, this time using points of vector 1.
d1 = (a2 * v1x1) + (b2 * v1y1) + c2;
d2 = (a2 * v1x2) + (b2 * v1y2) + c2;
// Again, if both have the same sign (and neither one is 0),
// no intersection is possible.
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// If we get here, only two possibilities are left. Either the two
// vectors intersect in exactly one point or they are collinear, which
// means they intersect in any number of points from zero to infinite.
if ((a1 * b2) - (a2 * b1) == 0.0f) return COLLINEAR;
// If they are not collinear, they must intersect in exactly one point.
return YES;
}
ค่าอินพุตคือจุดปลายสองจุดของเวกเตอร์ 1 ( v1x1/v1y1และv1x2/v1y2) และเวกเตอร์ 2 ( v2x1/v2y1และv2x2/v2y2) คุณมีเวกเตอร์ 2 ตัว, 4 คะแนน, 8 พิกัด YESและNOมีความชัดเจน YESเพิ่มทางแยกNOไม่ทำอะไรเลย
แล้ว COLLINEAR ล่ะ? มันหมายถึงเวกเตอร์ทั้งสองอยู่ในแนวอนันต์เดียวกันทั้งนี้ขึ้นอยู่กับตำแหน่งและความยาวพวกเขาไม่ได้ตัดกันเลยหรือพวกเขาตัดกันในจำนวนไม่รู้จบ ฉันไม่แน่ใจว่าจะจัดการกับกรณีนี้ได้อย่างไรฉันจะไม่นับเป็นจุดตัดทั้งสองทาง กรณีนี้ค่อนข้างหายากในทางปฏิบัติแล้วเนื่องจากข้อผิดพลาดในการปัดเศษทศนิยม โค้ดที่ดีกว่าอาจจะไม่ทดสอบ== 0.0fแต่แทนที่จะเป็นอย่าง< epsilonepsilon ซึ่งมีจำนวนน้อย
หากคุณต้องการทดสอบจำนวนจุดที่มากขึ้นคุณสามารถเร่งความเร็วของสิ่งต่าง ๆ ได้อย่างแน่นอนโดยการรักษารูปแบบมาตรฐานสมการเชิงเส้นของด้านรูปหลายเหลี่ยมในหน่วยความจำดังนั้นคุณไม่จำเป็นต้องคำนวณใหม่ทุกครั้ง การทำเช่นนี้จะช่วยให้คุณได้การคูณทศนิยมแบบสองจุดและการลบจุดลอยสามจุดในการทดสอบทุกครั้งเพื่อแลกกับการเก็บค่าจุดลอยตัวสามค่าต่อด้านรูปหลายเหลี่ยมในหน่วยความจำ มันเป็นช่วงเวลาปกติของการคำนวณเทียบกับหน่วยความจำ
สุดท้าย แต่ไม่ท้ายสุด: หากคุณอาจใช้ฮาร์ดแวร์ 3D เพื่อแก้ไขปัญหามีทางเลือกที่น่าสนใจ ปล่อยให้ GPU ทำทุกอย่างให้คุณ สร้างพื้นผิวการทาสีที่อยู่นอกหน้าจอ เติมให้สมบูรณ์ด้วยสีดำ ตอนนี้ให้ OpenGL หรือ Direct3D วาดรูปหลายเหลี่ยมของคุณ (หรือแม้กระทั่งรูปหลายเหลี่ยมทั้งหมดของคุณหากคุณต้องการทดสอบว่าจุดนั้นอยู่ในรูปใดรูปหนึ่งหรือไม่ แต่คุณไม่สนใจว่ารูปใดมีรูปหลายเหลี่ยมที่แตกต่างกัน สีเช่นสีขาว ในการตรวจสอบว่าจุดหนึ่งอยู่ในรูปหลายเหลี่ยมหรือไม่ให้รับสีของจุดนี้จากพื้นผิวการวาด นี่เป็นเพียงการดึงหน่วยความจำ O (1)
แน่นอนว่าวิธีนี้ใช้ได้เฉพาะเมื่อพื้นผิวการวาดของคุณไม่จำเป็นต้องมีขนาดใหญ่มาก หากไม่สามารถใส่ลงในหน่วยความจำ GPU ได้วิธีนี้จะช้ากว่าการทำบน CPU ถ้ามันจะต้องมีขนาดใหญ่และ GPU ของคุณรองรับเฉดสีที่ทันสมัยคุณยังคงสามารถใช้ GPU ได้โดยการใช้การหล่อเรย์ที่แสดงด้านบนเป็นตัวแบ่ง GPU ซึ่งเป็นไปได้อย่างแน่นอน สำหรับรูปหลายเหลี่ยมที่มีขนาดใหญ่กว่าหรือมีจำนวนมากในการทดสอบสิ่งนี้จะจ่ายออกไปพิจารณาว่า GPU บางรุ่นจะสามารถทดสอบ 64 ถึง 256 จุดในแบบคู่ขนาน โปรดทราบว่าการถ่ายโอนข้อมูลจาก CPU ไปยัง GPU และด้านหลังนั้นมีราคาแพงเสมอดังนั้นสำหรับการทดสอบจุดสองสามจุดกับรูปหลายเหลี่ยมแบบง่าย ๆ ซึ่งจุดหรือรูปหลายเหลี่ยมนั้นเป็นแบบไดนามิกและจะเปลี่ยนบ่อยวิธี GPU จะไม่จ่ายเงิน ปิด
