मुझे दो तत्व मिले हैं, एक 2D बिंदु और एक आयताकार क्षेत्र। बिंदु उस क्षेत्र के मध्य का प्रतिनिधित्व करता है। मुझे उस क्षेत्र की चौड़ाई और ऊंचाई का भी पता है। और क्षेत्र ग्रिड के सापेक्ष 40 ° झुका हुआ है।
अब मैं केवल इस डेटा का उपयोग करके उस झुके हुए क्षेत्र के प्रत्येक कोने के निशान की पूर्ण स्थिति की गणना करना चाहता हूं। क्या यह संभव है?
जवाबों:
X = x*cos(θ) - y*sin(θ)
Y = x*sin(θ) + y*cos(θ)यह आपको मूल के चारों ओर एक बिंदु घुमाए गए डिग्री का स्थान देगा। चूंकि वर्ग के कोनों को वर्ग के केंद्र के चारों ओर घुमाया जाता है और मूल नहीं, इस सूत्र का उपयोग करने में सक्षम होने के लिए कुछ चरणों को जोड़ा जाना चाहिए। पहले आपको मूल के सापेक्ष बिंदु निर्धारित करने की आवश्यकता है। तब आप रोटेशन फॉर्मूला का उपयोग कर सकते हैं। रोटेशन के बाद आपको इसे स्क्वायर के केंद्र के सापेक्ष वापस ले जाने की आवश्यकता है।
// cx, cy - center of square coordinates
// x, y - coordinates of a corner point of the square
// theta is the angle of rotation
// translate point to origin
float tempX = x - cx;
float tempY = y - cy;
// now apply rotation
float rotatedX = tempX*cos(theta) - tempY*sin(theta);
float rotatedY = tempX*sin(theta) + tempY*cos(theta);
// translate back
x = rotatedX + cx;
y = rotatedY + cy;इसे सभी 4 कोनों पर लागू करें और आप कर रहे हैं!
एक समन्वय प्रणाली में अनुवाद करके एक धुरी के बारे में एक बिंदु को घुमाना एक सामान्य तकनीक है जहां धुरी मूल है, फिर इस मूल के बारे में घूमती है, फिर वापस विश्व निर्देशांक में अनुवाद करती है। (इस दृष्टिकोण की बहुत अच्छी व्याख्या खान अकादमी में उपलब्ध है )
हालाँकि, आप अपने आयत कोनों को दुनिया के निर्देशांक में जमा नहीं कर रहे हैं, इसलिए हम आपके द्वारा उपलब्ध डेटा के अनुरूप होने के लिए एक दृष्टिकोण दर्जी कर सकते हैं।
Cx, Cy // the coordinates of your center point in world coordinates
W // the width of your rectangle
H // the height of your rectangle
θ // the angle you wish to rotate
//The offset of a corner in local coordinates (i.e. relative to the pivot point)
//(which corner will depend on the coordinate reference system used in your environment)
Ox = W / 2
Oy = H / 2
//The rotated position of this corner in world coordinates
Rx = Cx + (Ox * cos(θ)) - (Oy * sin(θ))
Ry = Cy + (Ox * sin(θ)) + (Oy * cos(θ))यह दृष्टिकोण तब आसानी से अन्य तीन कोनों पर लागू किया जा सकता है।
अन्य उत्तरों के आधार पर, और उन्हें पूरक करने के लिए, मैं यहां P5 के साथ एक उदाहरण बनाने में कामयाब रहा ।
यहां वह कोड है, जिसे आप सीधे एक्सेस करना चाहते हैं:
function setup() {
createCanvas(400, 400);
}
var count = 0;
function draw() {
background(250);
rectMode(CENTER);
stroke(0,0,255);
fill(0,0,255);
count += 1;
var box1X = 100;
var box1Y = 100;
var box2X = 160;
var box2Y = 100;
var box1R = count;
var box2R = -60-count;
var box1W = 50;
var box1H = 50;
var box2W = 50;
var box2H = 50;
translate(box1X, box1Y);
rotate(radians(box1R));
rect(0, 0, box1W, box1H);
rotate(radians(-box1R));
translate(-box1X, -box1Y);
translate(box2X, box2Y);
rotate(radians(box2R));
rect(0, 0, box2W, box2H);
rotate(radians(-box2R));
translate(-box2X, -box2Y);
stroke(255,0,0);
fill(255,0,0);
var pointRotated = [];
pointRotated.push(GetPointRotated(box1X, box1Y, box1R, -box1W/2, box1H/2)); // Dot1
pointRotated.push(GetPointRotated(box1X, box1Y, box1R, box1W/2, box1H/2)); // Dot2
pointRotated.push(GetPointRotated(box1X, box1Y, box1R, -box1W/2, -box1H/2)); // Dot3
pointRotated.push(GetPointRotated(box1X, box1Y, box1R, box1W/2, -box1H/2)); // Dot4
pointRotated.push(createVector(box1X, box1Y)); // Dot5
for (var i=0;i<pointRotated.length;i++){
ellipse(pointRotated[i].x,pointRotated[i].y,3,3);
}
}
function GetPointRotated(X, Y, R, Xos, Yos){
// Xos, Yos // the coordinates of your center point of rect
// R // the angle you wish to rotate
//The rotated position of this corner in world coordinates
var rotatedX = X + (Xos * cos(radians(R))) - (Yos * sin(radians(R)))
var rotatedY = Y + (Xos * sin(radians(R))) + (Yos * cos(radians(R)))
return createVector(rotatedX, rotatedY)
}<script src="//cdnjs.cloudflare.com/ajax/libs/p5.js/0.3.3/p5.min.js"></script>ऊपर दिए गए कोड को फिर से साफ़ करने से एक साफ-सुथरा रूप मिलता है जो इस तथ्य को भी उजागर करता है कि प्रत्येक कोने मूल रूप से center + height/2 + width/2, प्रत्येक कोने के लिए उपयुक्त संकेतों के साथ है। यह भी अगर आप इलाज height/2औरwidth/2 घुमाया वैक्टर के रूप में है।
दुभाषियों को इनलाइन करने वालों पर भरोसा करना, यह बहुत प्रभावी होना चाहिए, क्या हमें इसे बेंचमार्क करने की कोशिश करनी चाहिए।
function addPoints(p1, p2) {
return { x: p1.x + p2.x, y: p1.y + p2.y }
}
function subPoints(p1, p2 ) {
return { x: p1.x - p2.x, y: p1.y - p2.y }
}
function multPoints(p1, p2 ) {
return { x: p1.x * p2.x, y: p1.y * p2.y }
}
function getRulerCorners() {
const sin = Math.sin(ruler.angle);
const cos = Math.cos(ruler.angle);
const height = { x: sin * ruler.height/2, y: cos * ruler.height/2 };
const heightUp = addPoints(ruler, multPoints({x: 1, y :-1}, height));
const heightDown = addPoints(ruler, multPoints({x: -1, y: 1}, height));
const width = { x: cos * ruler.width/2, y: sin * ruler.width/2 };
ruler.nw = subPoints(heightUp, width);
ruler.ne = addPoints(heightUp, width );
ruler.sw = subPoints(heightDown, width);
ruler.se = addPoints(heightDown, width);
}रोटेशन पर विकिपीडिया लेख देखें । सार यह है:
(1) यदि c केंद्र बिंदु है, तो कोने c + ( L / 2, W / 2), +/- आदि हैं, जहाँ L और W आयत की लंबाई और चौड़ाई हैं।
(2) आयत का अनुवाद करें ताकि केंद्र c मूल पर है, c को चारों कोनों से घटाकर ।
(3) उद्धृत सूत्र के माध्यम से आयत को 40 डिग्री तक घुमाएँ।
(4) प्रत्येक समन्वय में c जोड़कर वापस अनुवाद करें ।
संभवतः, समस्या को दो में विभाजित करके कुछ अनुकूलन उपलब्ध हैं:
नीचे कोड, यहां आयत को शासक कहा जाता है। ruler.x, ruler, y आयत केंद्र है।
/** Middle point on rulers's top side. */
function getRulerTopMiddle(cos, sin) {
return {
x : ruler.x + sin * ruler.height/2,
y : ruler.y - cos * ruler.height/2
}
}
/** Middle point on rulers's bottom side. */
function getRulerBottomMiddle(cos, sin) {
return {
x : ruler.x - sin * ruler.height/2,
y : ruler.y + cos * ruler.height/2
}
}
/** Update ruler's four corner coordinates. */
function getRulerCorners() {
const sin = Math.sin(ruler.angle);
const cos = Math.cos(ruler.angle);
const topMiddle = getRulerTopMiddle(cos, sin);
const bottomMiddle = getRulerBottomMiddle(cos, sin);
ruler.nw = {
x: topMiddle.x - (cos * ruler.width/2),
y: topMiddle.y - (sin * ruler.width/2)
}
ruler.ne = {
x: topMiddle.x + (cos * ruler.width/2),
y: topMiddle.y + (sin * ruler.width/2)
}
ruler.sw = {
x: bottomMiddle.x - (cos * ruler.width/2),
y: bottomMiddle.y - (sin * ruler.width/2)
}
ruler.se = {
x: bottomMiddle.x + (cos * ruler.width/2),
y: bottomMiddle.y + (sin * ruler.width/2)
}
}थोड़ा देर से, लेकिन यहाँ एक कॉम्पैक्ट फ़ंक्शन है जिसका मैंने उपयोग किया है। यह शीर्ष और बाएं बिंदुओं की गणना करता है, फिर उन्हें विपरीत कोनों के लिए फ्लिप करता है।
rotatedRect(float x, float y, float halfWidth, float halfHeight, float angle)
{
float c = cos(angle);
float s = sin(angle);
float r1x = -halfWidth * c - halfHeight * s;
float r1y = -halfWidth * s + halfHeight * c;
float r2x = halfWidth * c - halfHeight * s;
float r2y = halfWidth * s + halfHeight * c;
// Returns four points in clockwise order starting from the top left.
return
(x + r1x, y + r1y),
(x + r2x, y + r2y),
(x - r1x, y - r1y),
(x - r2x, y - r2y);
}पुरानी पोस्ट, लेकिन यहाँ यह करने का एक और तरीका है:
public static Point[] GetRotatedCorners(Rectangle rectangleToRotate, float angle)
{
// Calculate the center of rectangle.
Point center = new Point(rectangleToRotate.Left + (rectangleToRotate.Left + rectangleToRotate.Right) / 2, rectangleToRotate.Top + (rectangleToRotate.Top + rectangleToRotate.Bottom) / 2);
Matrix m = new Matrix();
// Rotate the center.
m.RotateAt(360.0f - angle, center);
// Create an array with rectangle's corners, starting with top-left corner and going clock-wise.
Point[] corners = new Point[]
{
new Point(rectangleToRotate.Left, rectangleToRotate.Top), // Top-left corner.
new Point(rectangleToRotate.Right, rectangleToRotate.Top), // Top-right corner.
new Point(rectangleToRotate.Right, rectangleToRotate.Bottom), // Bottom-right corner.
new Point(rectangleToRotate.Left, rectangleToRotate.Bottom), // Botton-left corner
};
// Now apply the matrix to every corner of the rectangle.
m.TransformPoints(corners);
// Return the corners of rectangle rotated by the provided angle.
return corners;
}आशा करता हूँ की ये काम करेगा!