Ejemplo n.º 1
0
        private void DrawPreview()
        {
            try
            {
                ImageCaptureInfo copy = imageCaptureInfo;
                copy.captureSizeX = previewPictureBox.Width;
                copy.captureSizeY = previewPictureBox.Height;

                //Show something in the preview
                previewImage = CaptureImageFullPreview(ref copy);
                float crop_size_x = copy.actual_crop_size_x;
                float crop_size_y = copy.actual_crop_size_y;

                lastFullCapture = previewImage;
                //Draw selection rectangle
                DrawCaptureRectangleBitmap();

                //Compute image crop coordinates according to selection rectangle

                //Get raw image size from imageCaptureInfo.actual_crop_size to compute scaling between raw and rectangle coordinates

                //Console.WriteLine("SIZE X: {0}, SIZE Y: {1}", imageCaptureInfo.actual_crop_size_x, imageCaptureInfo.actual_crop_size_y);

                imageCaptureInfo.crop_coordinate_left   = selectionRectanglePreviewBox.Left * (crop_size_x / previewPictureBox.Width);
                imageCaptureInfo.crop_coordinate_right  = selectionRectanglePreviewBox.Right * (crop_size_x / previewPictureBox.Width);
                imageCaptureInfo.crop_coordinate_top    = selectionRectanglePreviewBox.Top * (crop_size_y / previewPictureBox.Height);
                imageCaptureInfo.crop_coordinate_bottom = selectionRectanglePreviewBox.Bottom * (crop_size_y / previewPictureBox.Height);

                copy.crop_coordinate_left   = selectionRectanglePreviewBox.Left * (crop_size_x / previewPictureBox.Width);
                copy.crop_coordinate_right  = selectionRectanglePreviewBox.Right * (crop_size_x / previewPictureBox.Width);
                copy.crop_coordinate_top    = selectionRectanglePreviewBox.Top * (crop_size_y / previewPictureBox.Height);
                copy.crop_coordinate_bottom = selectionRectanglePreviewBox.Bottom * (crop_size_y / previewPictureBox.Height);

                Bitmap full_cropped_capture = CaptureImageFullPreview(ref copy, useCrop: true);
                croppedPreviewPictureBox.Image = full_cropped_capture;
                lastFullCroppedCapture         = full_cropped_capture;

                copy.captureSizeX = captureSize.Width;
                copy.captureSizeY = captureSize.Height;

                //Show matching bins for preview
                var        capture = CaptureImage();
                List <int> dummy;
                List <int> dummy2;
                int        black_level      = 0;
                var        features         = FeatureDetector.featuresFromBitmap(capture, out dummy, out black_level, out dummy2);
                int        tempMatchingBins = 0;
                var        isLoading        = FeatureDetector.compareFeatureVector(features.ToArray(), FeatureDetector.listOfFeatureVectorsEng, out tempMatchingBins, -1.0f, false);

                lastFeatures           = features;
                lastDiagnosticCapture  = capture;
                lastMatchingBins       = tempMatchingBins;
                matchDisplayLabel.Text = Math.Round((Convert.ToSingle(tempMatchingBins) / Convert.ToSingle(FeatureDetector.listOfFeatureVectorsEng.GetLength(1))), 4).ToString();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.ToString());
            }
        }
Ejemplo n.º 2
0
        public static Bitmap CaptureFromDisplay(ref ImageCaptureInfo info)
        {
            Bitmap b = new Bitmap((int)info.actual_crop_size_x, (int)info.actual_crop_size_y);

            //Full screen capture
            using (Graphics g = Graphics.FromImage(b))
            {
                g.CopyFromScreen((int)(info.center_of_frame_x - info.actual_crop_size_x / 2 + info.actual_offset_x),
                                 (int)(info.center_of_frame_y - info.actual_crop_size_y / 2 + info.actual_offset_y), 0, 0, new Size((int)info.actual_crop_size_x, (int)info.actual_crop_size_y), CopyPixelOperation.SourceCopy);
            }

            b = ResizeImage(b, info.captureSizeX, info.captureSizeY);

            return(b);
        }
Ejemplo n.º 3
0
        private void initImageCaptureInfo()
        {
            imageCaptureInfo = new ImageCaptureInfo();

            selectionTopLeft             = new Point(0, 0);
            selectionBottomRight         = new Point(previewPictureBox.Width, previewPictureBox.Height);
            selectionRectanglePreviewBox = new Rectangle(selectionTopLeft.X, selectionTopLeft.Y, selectionBottomRight.X - selectionTopLeft.X, selectionBottomRight.Y - selectionTopLeft.Y);

            imageCaptureInfo.featureVectorResolutionX = featureVectorResolutionX;
            imageCaptureInfo.featureVectorResolutionY = featureVectorResolutionY;
            imageCaptureInfo.captureSizeX             = captureSize.Width;
            imageCaptureInfo.captureSizeY             = captureSize.Height;
            imageCaptureInfo.cropOffsetX        = cropOffsetX;
            imageCaptureInfo.cropOffsetY        = cropOffsetY;
            imageCaptureInfo.captureAspectRatio = captureAspectRatioX / captureAspectRatioY;
        }
Ejemplo n.º 4
0
        //Should probably refactor this into some kind of struct, whatever...
        public static void SizeAdjustedCropAndOffset(int device_width, int device_height, ref ImageCaptureInfo info)
        {
            var resolution_factor_x = (device_width / info.featureVectorResolutionX);

            var resolution_factor_y = (device_height / info.featureVectorResolutionY);



            info.actual_crop_size_x = info.captureSizeX * resolution_factor_x;

            info.actual_crop_size_y = info.captureSizeY * resolution_factor_y;

            //Scale offset depending on resolution
            info.actual_offset_x = info.cropOffsetX * resolution_factor_x;

            info.actual_offset_y = info.cropOffsetY * resolution_factor_y;

            //Scale offset and sizes depending on actual vs. needed aspect ratio

            if (((float)device_width / (float)device_height) > (info.captureAspectRatio))
            {
                var image_region = (float)device_height / (1.0f / info.captureAspectRatio);

                //Aspect ratio is larger than original
                var black_bar_width_total = (float)device_width - image_region;

                //Compute space occupied by black border relative to total width
                var adjust_factor = ((float)(device_width - black_bar_width_total) / (float)device_width);
                //info.actual_crop_size_x *= adjust_factor;
                //info.actual_offset_x *= adjust_factor;
            }
            else
            {
                var image_region = (float)device_width / (info.captureAspectRatio);

                //Aspect ratio is larger than original
                var black_bar_height_total = (float)device_height - image_region;

                //Compute space occupied by black border relative to total width
                var adjust_factor = ((float)(device_height - black_bar_height_total) / (float)device_height);
                //info.actual_crop_size_y *= adjust_factor;
                //info.actual_offset_y *= adjust_factor;
            }



            info.center_of_frame_x = device_width / 2;

            info.center_of_frame_y = device_height / 2;
        }
Ejemplo n.º 5
0
        public static Bitmap PrintWindow(IntPtr hwnd, ref ImageCaptureInfo info, bool full = false, bool useCrop = false, float scalingValueFloat = 1.0f)
        {
            try
            {
                Rectangle rc;
                DLLImportStuff.GetClientRect(hwnd, out rc);

                Bitmap ret = new Bitmap(1, 1);

                if (rc.Width < 0)
                {
                    return(ret);
                }

                IntPtr hdcwnd = DLLImportStuff.GetDC(hwnd);
                IntPtr hdc    = DLLImportStuff.CreateCompatibleDC(hdcwnd);

                rc.Width  = (int)(rc.Width * scalingValueFloat);
                rc.Height = (int)(rc.Height * scalingValueFloat);



                if (useCrop)
                {
                    //Change size according to selected crop
                    rc.Width  = (int)(info.crop_coordinate_right - info.crop_coordinate_left);
                    rc.Height = (int)(info.crop_coordinate_bottom - info.crop_coordinate_top);
                }



                //Compute crop coordinates and width/ height based on resoution
                ImageCapture.SizeAdjustedCropAndOffset(rc.Width, rc.Height, ref info);



                float cropOffsetX = info.actual_offset_x;
                float cropOffsetY = info.actual_offset_y;

                if (full)
                {
                    info.actual_offset_x = 0;
                    info.actual_offset_y = 0;

                    info.actual_crop_size_x = 2 * info.center_of_frame_x;
                    info.actual_crop_size_y = 2 * info.center_of_frame_y;
                }

                if (useCrop)
                {
                    //Adjust for crop offset
                    info.center_of_frame_x += info.crop_coordinate_left;
                    info.center_of_frame_y += info.crop_coordinate_top;
                }


                IntPtr hbmp = DLLImportStuff.CreateCompatibleBitmap(hdcwnd, (int)info.actual_crop_size_x, (int)info.actual_crop_size_y);

                DLLImportStuff.SelectObject(hdc, hbmp);

                DLLImportStuff.BitBlt(hdc, 0, 0, (int)info.actual_crop_size_x, (int)info.actual_crop_size_y, hdcwnd, (int)(info.center_of_frame_x + info.actual_offset_x - info.actual_crop_size_x / 2),
                                      (int)(info.center_of_frame_y + info.actual_offset_y - info.actual_crop_size_y / 2), DLLImportStuff.TernaryRasterOperations.SRCCOPY);



                info.actual_offset_x = cropOffsetX;
                info.actual_offset_y = cropOffsetY;


                ret = (Bitmap)Image.FromHbitmap(hbmp).Clone();

                DLLImportStuff.DeleteObject(hbmp);
                DLLImportStuff.ReleaseDC(hwnd, hdcwnd);
                DLLImportStuff.DeleteDC(hdc);

                return(ResizeImage(ret, info.captureSizeX, info.captureSizeY));
            }
            catch (System.Runtime.InteropServices.ExternalException)
            {
                return(new Bitmap(10, 10));
            }
        }
Ejemplo n.º 6
0
        private Bitmap CaptureImageFullPreview(ref ImageCaptureInfo imageCaptureInfo, bool useCrop = false)
        {
            Bitmap b = new Bitmap(1, 1);

            //Full screen capture
            if (processCaptureIndex < 0)
            {
                Screen    selected_screen = Screen.AllScreens[-processCaptureIndex - 1];
                Rectangle screenRect      = selected_screen.Bounds;

                screenRect.Width  = (int)(screenRect.Width * scalingValueFloat);
                screenRect.Height = (int)(screenRect.Height * scalingValueFloat);

                Point screenCenter = new Point((int)(screenRect.Width / 2.0f), (int)(screenRect.Height / 2.0f));

                if (useCrop)
                {
                    //Change size according to selected crop
                    screenRect.Width  = (int)(imageCaptureInfo.crop_coordinate_right - imageCaptureInfo.crop_coordinate_left);
                    screenRect.Height = (int)(imageCaptureInfo.crop_coordinate_bottom - imageCaptureInfo.crop_coordinate_top);
                }

                //Compute crop coordinates and width/ height based on resoution
                ImageCapture.SizeAdjustedCropAndOffset(screenRect.Width, screenRect.Height, ref imageCaptureInfo);

                imageCaptureInfo.actual_crop_size_x = 2 * imageCaptureInfo.center_of_frame_x;
                imageCaptureInfo.actual_crop_size_y = 2 * imageCaptureInfo.center_of_frame_y;

                if (useCrop)
                {
                    //Adjust for crop offset
                    imageCaptureInfo.center_of_frame_x += imageCaptureInfo.crop_coordinate_left;
                    imageCaptureInfo.center_of_frame_y += imageCaptureInfo.crop_coordinate_top;
                }

                //Adjust for selected screen offset
                imageCaptureInfo.center_of_frame_x += selected_screen.Bounds.X;
                imageCaptureInfo.center_of_frame_y += selected_screen.Bounds.Y;

                imageCaptureInfo.actual_offset_x = 0;
                imageCaptureInfo.actual_offset_y = 0;

                b = ImageCapture.CaptureFromDisplay(ref imageCaptureInfo);

                imageCaptureInfo.actual_offset_x = cropOffsetX;
                imageCaptureInfo.actual_offset_y = cropOffsetY;
            }
            else
            {
                IntPtr handle = new IntPtr(0);

                if (processCaptureIndex >= processList.Length)
                {
                    return(b);
                }

                if (processCaptureIndex != -1)
                {
                    handle = processList[processCaptureIndex].MainWindowHandle;
                }
                //Capture from specific process
                processList[processCaptureIndex].Refresh();
                if ((int)handle == 0)
                {
                    return(b);
                }

                b = ImageCapture.PrintWindow(handle, ref imageCaptureInfo, full: true, useCrop: useCrop, scalingValueFloat: scalingValueFloat);
            }

            return(b);
        }