چگونه می توانم زاویه چرخش یک عکس را محاسبه نمایم؟

[drDBase]

باسلام خدمت دوستان گرامی
م یک نرم افزار نوشتم که تصاویر اسکن شده رو می گیره و ازش یک سری مقادیر رو بدست میاره
اما زمانی که تصویر دچار زاویه میشه نرم افزار بال خطا مواجه میشه
راه حل اینه که نرم افزار بتونه تشخیص بده عکس در چه جهتی و چند درجه چرخش داشته تا به حالت قبل برش گردونه
اما نمیدونم چطور این کارو انجام بدم
از اساتید خواهش می کنم یه راهنمایی بکنن
کارم فوریه

[مصطفی ساتکی]

سلام.
یکبار امروز این سوال رو به نحوی پاسخ دادم
شما برای تشیخص خطوط خیلی مبتدی کار کنید می تونید یک سری key point بدست بیارید که این نقاط رو به عنوان معیار در نظر بگیرید و بعد زاویه اون نقاط نسبت به هم رو بدست بیارید به فرض مثال این نقاط می تونن corner ها در تصویر ورودیتون باشه.
حالا دیگر همون hough line detection که در 2 حالت simple و statistic استفادش کنید که به صورت trad off بدست به دقت و سرعت اجرا داره اوله دقتش خوبه و دومی سرعت اجراش.

تذکر : شما بایستی در صفحه یک سری خطوطی داشته باشید که بعد نسبت به اون خطوط زاویه رو تشخیص بدید

[drDBase]

ممنون دوست عزیز همین کارو انجام دادم و جواب گرفتم
اما برای برگردوندن تصویر به حالت قبل مشکل دارم
یه تابع نوشتم که این کارو انجام بده ولی درست جواب نمیده
دوستان یه نگاهی بکنن ببینن دلیلش چیه؟
البته عکسو تغییر میده ولی درست عمل نمیکنه

کد:

public Bitmap RotateImage(Bitmap b, double radAngel)
{
Bitmap returnBitmap = new Bitmap(b.Width, b.Height);
Graphics g = Graphics.FromImage(returnBitmap);
g.TranslateTransform((float)b.Width / 2, (float)b.Height / 2);
g.RotateTransform((float)radAngel);
g.TranslateTransform(-(float)b.Width / 2, -(float)b.Height / 2);
g.DrawImage(b, new Point(0, 0));
return returnBitmap;
}

[drDBase]

این مشکل رو هم با این قطعه کد حلش کردم
میزارم اینجا تا به درد بقیه هم بخوره
public Bitmap RotateImage(Bitmap b, double angel)
{
if (b == null)
throw new ArgumentNullException("image");

const double pi2 = Math.PI / 2.0;

// Why can't C#‎ allow these to be const, or at least readonly
// *sigh* I'm starting to talk like Christian Graus :omg:
double oldWidth = (double)b.Width;
double oldHeight = (double)b.Height;

// Convert degrees to radians
double theta = ((double)angel) * Math.PI / 180.0;
double locked_theta = theta;

// Ensure theta is now [0, 2pi)
while (locked_theta < 0.0)
locked_theta += 2 * Math.PI;

double newWidth, newHeight;
int nWidth, nHeight; // The newWidth/newHeight expressed as ints

#region Explaination of the calculations
/*
* The trig involved in calculating the new width and height
* is fairly simple; the hard part was remembering that when
* PI/2 <= theta <= PI and 3PI/2 <= theta < 2PI the width and
* height are switched.
*
* When you rotate a rectangle, r, the bounding box surrounding r
* contains for right-triangles of empty space. Each of the
* triangles hypotenuse's are a known length, either the width or
* the height of r. Because we know the length of the hypotenuse
* and we have a known angle of rotation, we can use the trig
* function identities to find the length of the other two sides.
*
* sine = opposite/hypotenuse
* cosine = adjacent/hypotenuse
*
* solving for the unknown we get
*
* opposite = sine * hypotenuse
* adjacent = cosine * hypotenuse
*
* Another interesting point about these triangles is that there
* are only two different triangles. The proof for which is easy
* to see, but its been too long since I've written a proof that
* I can't explain it well enough to want to publish it.
*
* Just trust me when I say the triangles formed by the lengths
* width are always the same (for a given theta) and the same
* goes for the height of r.
*
* Rather than associate the opposite/adjacent sides with the
* width and height of the original bitmap, I'll associate them
* based on their position.
*
* adjacent/oppositeTop will refer to the triangles making up the
* upper right and lower left corners
*
* adjacent/oppositeBottom will refer to the triangles making up
* the upper left and lower right corners
*
* The names are based on the right side corners, because thats
* where I did my work on paper (the right side).
*
* Now if you draw this out, you will see that the width of the
* bounding box is calculated by adding together adjacentTop and
* oppositeBottom while the height is calculate by adding
* together adjacentBottom and oppositeTop.
*/
#endregion

double adjacentTop, oppositeTop;
double adjacentBottom, oppositeBottom;

// We need to calculate the sides of the triangles based
// on how much rotation is being done to the bitmap.
// Refer to the first paragraph in the explaination above for
// reasons why.
if ((locked_theta >= 0.0 && locked_theta < pi2) ||
(locked_theta >= Math.PI && locked_theta < (Math.PI + pi2)))
{
adjacentTop = Math.Abs(Math.Cos(locked_theta)) * oldWidth;
oppositeTop = Math.Abs(Math.Sin(locked_theta)) * oldWidth;

adjacentBottom = Math.Abs(Math.Cos(locked_theta)) * oldHeight;
oppositeBottom = Math.Abs(Math.Sin(locked_theta)) * oldHeight;
}
else
{
adjacentTop = Math.Abs(Math.Sin(locked_theta)) * oldHeight;
oppositeTop = Math.Abs(Math.Cos(locked_theta)) * oldHeight;

adjacentBottom = Math.Abs(Math.Sin(locked_theta)) * oldWidth;
oppositeBottom = Math.Abs(Math.Cos(locked_theta)) * oldWidth;
}

newWidth = adjacentTop + oppositeBottom;
newHeight = adjacentBottom + oppositeTop;

nWidth = (int)Math.Ceiling(newWidth);
nHeight = (int)Math.Ceiling(newHeight);

Bitmap rotatedBmp = new Bitmap(nWidth, nHeight);

using (Graphics g = Graphics.FromImage(rotatedBmp))
{
// This array will be used to pass in the three points that
// make up the rotated image
Point[] points;

/*
* The values of opposite/adjacentTop/Bottom are referring to
* fixed locations instead of in relation to the
* rotating image so I need to change which values are used
* based on the how much the image is rotating.
*
* For each point, one of the coordinates will always be 0,
* nWidth, or nHeight. This because the Bitmap we are drawing on
* is the bounding box for the rotated bitmap. If both of the
* corrdinates for any of the given points wasn't in the set above
* then the bitmap we are drawing on WOULDN'T be the bounding box
* as required.
*/
if (locked_theta >= 0.0 && locked_theta < pi2)
{
points = new Point[] {
new Point( (int) oppositeBottom, 0 ),
new Point( nWidth, (int) oppositeTop ),
new Point( 0, (int) adjacentBottom )
};

}
else if (locked_theta >= pi2 && locked_theta < Math.PI)
{
points = new Point[] {
new Point( nWidth, (int) oppositeTop ),
new Point( (int) adjacentTop, nHeight ),
new Point( (int) oppositeBottom, 0 )
};
}
else if (locked_theta >= Math.PI && locked_theta < (Math.PI + pi2))
{
points = new Point[] {
new Point( (int) adjacentTop, nHeight ),
new Point( 0, (int) adjacentBottom ),
new Point( nWidth, (int) oppositeTop )
};
}
else
{
points = new Point[] {
new Point( 0, (int) adjacentBottom ),
new Point( (int) oppositeBottom, 0 ),
new Point( (int) adjacentTop, nHeight )
};
}

g.DrawImage(b, points);
}

return rotatedBmp;
}