public void AnalyseLayout_RotatedImage(RotateFlipType? rotation)
 {
     using (var img = new Bitmap(@".\phototest.tif")) {
         if (rotation.HasValue) img.RotateFlip(rotation.Value);
         engine.DefaultPageSegMode = PageSegMode.AutoOsd;
         using (var page = engine.Process(img)) {
             using (var pageLayout = page.GetIterator()) {
                 pageLayout.Begin();
                 do {
                     var result = pageLayout.GetProperties();
                     // Note: The orientation always seem to be 'PageUp' in Tesseract 3.02 according to this test.
                     Assert.That(result.Orientation, Is.EqualTo(Orientation.PageUp));
                     if (rotation == RotateFlipType.Rotate180FlipNone) {
                         // This isn't correct...
                         Assert.That(result.WritingDirection, Is.EqualTo(WritingDirection.LeftToRight));
                         Assert.That(result.TextLineOrder, Is.EqualTo(TextLineOrder.TopToBottom));
                     } else if (rotation == RotateFlipType.Rotate90FlipNone) {
                         Assert.That(result.WritingDirection, Is.EqualTo(WritingDirection.TopToBottom));
                         Assert.That(result.TextLineOrder, Is.EqualTo(TextLineOrder.RightToLeft));
                     } else if (rotation == null) {
                         Assert.That(result.WritingDirection, Is.EqualTo(WritingDirection.LeftToRight));
                         Assert.That(result.TextLineOrder, Is.EqualTo(TextLineOrder.TopToBottom));
                     }
                     // Not sure...
                 } while (pageLayout.Next(PageIteratorLevel.Block));
             }
         }
     }
 }

        protected override void addimage(location state, Brand brand, RotateFlipType rotate)
        {
            Bitmap bitmap;
            // �p�G�O�i�����P�N�]�w��ܵP���ϫ��A�_�h�N��ܪ��ߪ��P Resources.upbarnd
            if (brand.IsCanSee || state == location.South || ShowAll)
                bitmap = new Bitmap(brand.image);
            else
                bitmap = new Bitmap(Resources.upbarnd);
            // �]�w�P
            BrandBox tempBrandbox = new BrandBox(brand);

            // �]�w�۰��Y��
            tempBrandbox.SizeMode = PictureBoxSizeMode.AutoSize;

            // �]�w��Z
            tempBrandbox.Margin = new Padding(0);
            tempBrandbox.Padding = new Padding(padding);

            // �n�઺����
            bitmap.RotateFlip(rotate);

            // ����
            if (ShowAll && ShowBrandInfo)
                tempBrandbox.Click += new EventHandler(debug_Click);

            // �ƹ��ƥ�
            if (
                state == location.South
                && brand.getClass() != Settings.Default.Flower
                && brand.Team < 1
                )
            {
                tempBrandbox.MouseMove += new MouseEventHandler(tempBrandbox_MouseMove);
                tempBrandbox.MouseLeave += new EventHandler(brandBox_MouseLeave);
                tempBrandbox.Click += new EventHandler(brandBox_MouseClick);

                // �@���ƥ�
                //if (ShowAll && ShowBrandInfo)
                //    tempBrandbox.MouseHover += new EventHandler(debug_Click);
                //else
                //    tempBrandbox.MouseHover -= new EventHandler(debug_Click);
            }
            else if (cheat && state != location.South)
            {
                tempBrandbox.MouseClick += new MouseEventHandler(cheat_MouseClick);
            }
            else
            {
                tempBrandbox.Click -= new EventHandler(brandBox_MouseClick);
                tempBrandbox.MouseClick -= new MouseEventHandler(cheat_MouseClick);

            }
            bitmap = ResizeBitmap(bitmap, Settings.Default.ResizePercentage);

            // �]�w�Ϥ�
            tempBrandbox.Image = bitmap;

            // �s�W�ܱ��
            add_flowLayoutBrands(state, tempBrandbox);
        }

 public static RotateFlipType GetFlipTypeRotatedCW(RotateFlipType currentRotation)
 {
     RotateFlipType newRotation;
     switch (currentRotation)
     {
         case RotateFlipType.RotateNoneFlipNone:
             newRotation = RotateFlipType.Rotate90FlipNone;
             break;
         case RotateFlipType.Rotate90FlipNone:
             newRotation = RotateFlipType.Rotate180FlipNone;
             break;
         case RotateFlipType.Rotate180FlipNone:
         case RotateFlipType.RotateNoneFlipY: // legacy images
             newRotation = RotateFlipType.Rotate270FlipNone;
             break;
         case RotateFlipType.Rotate270FlipNone:
             newRotation = RotateFlipType.RotateNoneFlipNone;
             break;
         default:
             Debug.Fail("Unknown RotateFlipType encountered: " + currentRotation.ToString());
             newRotation = RotateFlipType.RotateNoneFlipNone;
             break;
     }
     return newRotation;
 }

 public static Bitmap RotateFlip(RotateFlipType rotateFlipType, Bitmap input)
 {
     Bitmap temp = input;
     Bitmap bmap = (Bitmap)temp.Clone();
     bmap.RotateFlip(rotateFlipType);
     return (Bitmap)bmap.Clone();
 }

 public void RotateFlip(RotateFlipType rotateFlipType)
 {
     Bitmap temp = (Bitmap)m_CurrentImage;
     Bitmap bmap = (Bitmap)temp.Clone();
     bmap.RotateFlip(rotateFlipType);
     m_CurrentImage = (Bitmap)bmap.Clone();
 }

        /// <summary>
        /// Resizes and rotates an image, keeping the original aspect ratio. Does not dispose the original
        /// Image instance.
        /// </summary>
        /// <param name="image">Image instance</param>
        /// <param name="width">desired width</param>
        /// <param name="height">desired height</param>
        /// <param name="rotateFlipType">desired RotateFlipType</param>
        /// <returns>new resized/rotated Image instance</returns>
        public static System.Drawing.Image Resize(System.Drawing.Image image, int width, 
            int height, RotateFlipType rotateFlipType)
        {
            // clone the Image instance, since we don't want to resize the original Image instance
            var rotatedImage = image.Clone() as System.Drawing.Image;
            //rotatedImage.RotateFlip(rotateFlipType);
            var newSize = CalculateResizedDimensions(rotatedImage, width, height);

            var resizedImage = new Bitmap(newSize.Width, newSize.Height, PixelFormat.Format32bppArgb);
            resizedImage.SetResolution(72, 72);

            using (var graphics = Graphics.FromImage(resizedImage))
            {
                // set parameters to create a high-quality thumbnail
                graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                graphics.SmoothingMode = SmoothingMode.AntiAlias;
                graphics.CompositingQuality = CompositingQuality.HighQuality;
                graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

                // use an image attribute in order to remove the black/gray border around image after resize
                // (most obvious on white images), see this post for more information:
                // http://www.codeproject.com/KB/GDI-plus/imgresizoutperfgdiplus.aspx
                using (var attribute = new ImageAttributes())
                {
                    attribute.SetWrapMode(WrapMode.TileFlipXY);

                    // draws the resized image to the bitmap
                    graphics.DrawImage(rotatedImage, new Rectangle(new Point(0, 0), newSize), 0, 0, rotatedImage.Width, rotatedImage.Height, GraphicsUnit.Pixel, attribute);
                }
            }

            return resizedImage;
        }

        public RotateTool(IDrawingFeatures drawingFeatures, RotateFlipType rotateType)
        {
            _drawingFeatures = drawingFeatures;
            _rotateType = rotateType;

            _drawingFeatures.DrawingHistory.CanceledShares = new Stack<AUndoable>();
            _previousImage = (Bitmap)_drawingFeatures.PaintingArea.Image.Clone();
        }

 // Modified behavior
 public void Rotate(RotateFlipType rotation, IEnumerable<Bitmap> images)
 {
     if (decorated == null)
         return;
     Parallel.ForEach(images, b =>
         {
             b.RotateFlip(rotation);
         });
 }

        public static bool RotationatePathIfNeeded(string path, RotateFlipType type)
        {
            if (type == RotateFlipType.RotateNoneFlipNone)
                return false;

            var bmp = Bitmap.FromFile (path);
            bmp.RotateFlip (type);
            bmp.Save (path);

            return true;
        }

 public static bool IsRotated90(RotateFlipType rotation)
 {
     switch (rotation)
     {
         case RotateFlipType.Rotate90FlipNone:
         case RotateFlipType.Rotate90FlipX:
         case RotateFlipType.Rotate90FlipXY:
         case RotateFlipType.Rotate90FlipY:
             return true;
         default:
             return false;
     }
 }

        public static Image RotateImage(Image img, RotateFlipType type)
        {
            var bmp = new Bitmap(img);

            using (Graphics gfx = Graphics.FromImage(bmp))
            {
                gfx.Clear(Color.White);
                gfx.DrawImage(img, 0, 0, img.Width, img.Height);
            }

            bmp.RotateFlip(type);
            return bmp;
        }

        private int DrawTile(int Tile, int X, int Y, RotateFlipType Rotate)
        {
            Paifu.PaifuTileImage TileImage = new Paifu.PaifuTileImage(Tile, Scale, Red);
            Bitmap TileBitmap = TileImage.Bmp;

            switch (Rotate)
            {
                case RotateFlipType.Rotate90FlipNone: TileBitmap.RotateFlip(Rotate); Y += (TileHeight - TileWidth); break;
                case RotateFlipType.Rotate270FlipNone: TileBitmap.RotateFlip(Rotate); Y += (TileHeight - TileWidth); break;
            }

            G.DrawImage(TileBitmap, new Point(X, Y));

            return TileBitmap.Width;
        }

        public CScanViewer()
        {
            InitializeComponent();

            this.Location = new Point(10, 10);
            this.Size = new Size(10, 10);
            this.Visible = true;
            rotate = RotateFlipType.Rotate90FlipNone;       // RotateFlipType.Rotate90FlipXY
            frameSize = new Size(0, 0);

            this.NewFrame += new AForge.Controls.VideoSourcePlayer.NewFrameHandler(frameHandler);
            this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.mouseDownHandler);
            this.MouseUp += new System.Windows.Forms.MouseEventHandler(this.mouseUpHandler);
            this.MouseMove += new System.Windows.Forms.MouseEventHandler(this.mouseMoveHandler);
        }

 void okButton_Click(object sender, RoutedEventArgs e)
 {
     this.DialogResult = true;
     try
     {
         if (RB90.IsChecked.HasValue && RB90.IsChecked.Value)
             angle = RotateFlipType.Rotate90FlipNone;
         else if (RB180.IsChecked.HasValue && RB180.IsChecked.Value)
             angle = RotateFlipType.Rotate180FlipNone;
         else if (RB270.IsChecked.HasValue && RB270.IsChecked.Value)
             angle = RotateFlipType.Rotate270FlipNone;
     }
     catch (Exception ex)
     {
         Console.Error.WriteLine(ex.Data);
     }
 }

        public void ImageRecognized(long metric, RotateFlipType rotate, List<RecognizedWord> words)
        {
            lock (metrics)
            {
                metrics[rotate] = metric;
            }

            lock (imagesWords)
            {
                imagesWords[rotate] = words;
            }

            if (Interlocked.Decrement(ref OperationsRemain) == 0)
            {
                isImagesParsingDone.Set();
            }
        }

 void okButton_Click(object sender, RoutedEventArgs e)
 {
     this.DialogResult = true;
     try
     {
         if (CBHoriz.IsChecked.HasValue && CBHoriz.IsChecked.Value &&
             CBVert.IsChecked.HasValue && CBVert.IsChecked.Value)
             mirror = RotateFlipType.RotateNoneFlipXY;
         else if (CBHoriz.IsChecked.HasValue && CBHoriz.IsChecked.Value)
             mirror = RotateFlipType.RotateNoneFlipX;
         else if (CBVert.IsChecked.HasValue && CBVert.IsChecked.Value)
             mirror = RotateFlipType.RotateNoneFlipY;
     }
     catch (Exception ex)
     {
         Console.Error.WriteLine(ex.Data);
     }
 }

        /// <summary>
        /// Rotates a given animation
        /// </summary>
        /// <param name="image">Target image</param>
        /// <param name="rotation">Desired rotation</param>
        /// <param name="counterRotation">The complement of the desired rotation</param>
        /// <returns>Transformed image</returns>
        public virtual Bitmap RotateAnimation(Bitmap image, RotateFlipType rotation, RotateFlipType counterRotation)
        {
            // The idea lies in rotating the returnBitmap and "drawing" the "image" on the rotated
            // returnBitmap Then returnBitmap is rotated to the complementing ( 360 - rotation )
            // direction so the image seems normal

            Bitmap returnBitmap = new Bitmap(animationWidth, animationHeight);
            //make a graphics object from the empty bitmap
            using (Graphics gx = Graphics.FromImage(returnBitmap))
            {
                returnBitmap.RotateFlip(rotation);      // ex:Rotate 90

                //draw passed in image onto graphics object
                gx.InterpolationMode = InterpolationMode.HighQualityBicubic;
                gx.DrawImage(image, 0, 0, animationWidth, animationHeight);
                returnBitmap.RotateFlip(counterRotation);    // ex:Rotate 270 back
            }

            return returnBitmap;
        }

 public RotationTransform(RotateFlipType rotateFlipType)
 {
     switch (rotateFlipType)
     {
         case RotateFlipType.Rotate90FlipNone:
             Angle = 90.0;
             break;
         case RotateFlipType.Rotate180FlipNone:
             Angle = 180.0;
             break;
         case RotateFlipType.Rotate270FlipNone:
             Angle = 270.0;
             break;
         case RotateFlipType.RotateNoneFlipNone:
             Angle = 0.0;
             break;
         default:
             throw new ArgumentException();
     }
 }

	public static void CreateImage (RotateFlipType rotate, int movex, int movey, string text, Bitmap dest, Graphics grdest)
	{
		Color clr;
		Bitmap	bmp = new Bitmap (80, 80, PixelFormat.Format32bppArgb);	
		Graphics gr = Graphics.FromImage (bmp);
		gr.Clear (Color.White);
		
		gr.DrawLine (p, 10.0F, 10.0F, 70.0F, 70.0F);
		gr.DrawLine (p, 10.0F, 15.0F, 70.0F, 15.0F);
		gr.DrawRectangle (p, 10.0F, 10.0F, 60.0F, 60.0F);				
		bmp.RotateFlip (rotate);		
		
		for (int y = 0; y < 80; y++) {
			for (int x = 0; x < 80; x++) {				
				clr = bmp.GetPixel (x,y);
				dest.SetPixel (x+movex, y+movey, clr);
			}
		}							
		
		grdest.DrawString (text, new Font ("Arial", 8), br,  movex+5, movey+85);		
	}

 public void RotateFlip(RotateFlipType rotateFlipType)
 {
     Bitmap temp = (Bitmap)_currentBitmap;
     Bitmap bmap = (Bitmap)temp.Clone();
     bmap.RotateFlip(rotateFlipType);
     _currentBitmap = (Bitmap)bmap.Clone();
 }