Is there a way to accurately zoom in and out on a picture using C#?

[btb4198]

All,

I am having problem with Zoom. I make a small program, that when I click, it zooms into a picture. the problem I am having is after I zoom the 1st time getting the right values to do the next zoom in a new location I did not zoom to the place place. This is because I am get the back the round location when I click. I tried doing a slope of a line equation, but it is still not working.

here is my code:

       private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            if (Updatenow)
            {
                Graphics g = e.Graphics;
                Rectangle rect = this.ClientRectangle;
                Pen borderPen = new Pen(borderColor, 1);

                // g.DrawRectangle(borderPen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
                if (RecalcImage)
                {
                    if (Panflag)
                    {
                        Console.WriteLine(" Zoom Factor is " + zoomFactor);
                        if (rect.Width < imgWidth)
                            imagex = (zoomPointX * (-1) * (zoomFactor - 1));
                        else
                            imagex = (float)(rect.Width - imgWidth) / 2;

                        if (rect.Height < imgHeight)
                            imagey = (zoomPointY * (-1) * (zoomFactor - 1));
                        else
                            imagey = (float)(rect.Height - imgHeight) / 2;

                        Panflag = false;
                    }
                    g.DrawImage(currentFrame, imagex, imagey, imgWidth, imgHeight);
                    //  currentFrame = (Bitmap) pictureBox2.Image; ;
                    Updatenow = false;
                }

            }

        }
 private void pictureBox1_Click(object sender, EventArgs e)
        {
            MouseEventArgs arg = (MouseEventArgs)e;
            if (zoomFactor > 15)
            {
                zoomFactor = 15;
                return;

            }
           
            float M = zoomFactor - 1;
            float Bx = arg.Location.X - (M * Xclick);
            float By = arg.Location.Y - (M* yclick);
            float NewX = (arg.Location.X - Bx) /M;
            float NewY = (arg.Location.Y - By) /M;

            if (zoomFactor == 1)
            {
                NewX = arg.Location.X;
            }

            if (zoomFactor == 1)
            {
                NewY = arg.Location.Y;
            } 

            Xclick = NewX;
            yclick = NewY;
            CalXTXT.Text = Convert.ToString(NewX);
            CalYTXT.Text = Convert.ToString(NewY);            zoomFactor = zoomFactor * 1.5F;
            imagex = Xclick * (-1) * (zoomFactor - 1F);
            imagey = yclick * (-1) * (zoomFactor - 1F);

            imgWidthTXT.Text = Convert.ToString(pictureBox1.Width * zoomFactor);
            imgHeightTXT.Text = Convert.ToString(pictureBox1.Height * zoomFactor);            imgWidth = pictureBox1.Width * zoomFactor;
            imgHeight = pictureBox1.Height * zoomFactor;
            //  Zoom(zoom, ImageX, ImageY);
            Updatenow = true;
            Panflag = false;
            RecalcImage = true;
            pictureBox1.Refresh();
        }

 

[Mark44]

the problem I am having is after I zoom the 1st time getting the right values to do the next zoom in a new location I did not zoom to the place place. This is because I am get the back the round location when I click.

Your description is not very clear. What does "get the back the round location" mean?
I looked at your code, and at first thought that you might be getting bad values for NewX and NewY in your Click event handler. I looked up the types of X and Y and saw that they were both of type int, but since Bc and By are declared as floats, the values for NewX and NewY are obtained using floating point division rather than integer division, so that doesn't seem to be where the problem lies.

I tried doing a slope of a line equation, but it is still not working.

I don't know what you mean by this. My suggestion is to use the built-in debugger in Visual Studio, and step through your code to see what happens after the first time you zoom in.

 

[btb4198]

Sorry I meant I am getting the wrong location

 

[Mark44]

Again, use the debugger to step through your code. I'm guessing that there is a wrong calculation in your Click event handler, so I would definitely put a breakpoint at the first line in this handler. As you step through the code, look at how the values of the Local variables change, and compare them to the values you think the code should be producing.

 

[btb4198]

I been trying that, but I still not come up with the right calculation

 

[Mark44]

I been trying that, but I still not come up with the right calculation

This is why you need to be using the debugger -- to compare what you think the program should be doing against what it is actually doing. Before you run the code in the debugger, calculate by hand what a particular zoom factor should do. Then single step through your Click handler and see what it actually does. If the values you predicted are different from the values produced, there's your bug. Then you task is to rewrite the code that is producing incorrect values.

 

[btb4198]

So I did try that... but Idk if I am doing it wrong by hand. or what... but I did try that a lot . I tried have been using the debug and all of that .. still not working
Do you know the right equation?
have you done zoom before ?
do you have working code that does this ?

 

[Mark44]

Do you know the right equation?

have you done zoom before ?

do you have working code that does this ?

No, no, and no.
This is your program, so presumably you know what you want it to do.

Here's what I think you're trying to do. A computer monitor has a certain resolution, like 1200 pixels wide by 600 pixels deep. If you zoom in by a factor of 2, your program should take the portion of the image from window coordinates (300, 150) - upper left corner - to (900, 450) - lower right corner, and then display that portion of the image in the full 1200 x 600 window. Most monitors have higher resolution than this, but I'm using these numbers as an example.
In the example I gave, we took a part of the image that was 600 x 300, and displayed it in a rectangle that was twice as wide and twice as deep. I think that's what should happen if you zoom in by a factor of 2. A line segment that was 3" wide in appearance should show up as 6" wide after the zoom.

 

[btb4198]

So that is very close. I have a video Player from Afoger and I am pulling video from a webcam. I am using this
g.DrawImage(currentFrame, imagex, imagey, imgWidth, imgHeight);

so what I do is,
imageX = where I click at for X in the video player * (-1) * ( zoomFactor - 1)
imageY = where I click at for Y in the video player * (-1) * ( zoomFactor - 1)
imgWidth = this.Width * zoomFactor ( this.Width = videoplayer width not the bitmap)
imgHeight = this.Height * zoomFactor ( this.Height = videoplayer Height not the bitmap)

Somehow this places where you click at, at the same location after you zoom in the videoplayer. So
at start with no zoom there is a 1 to 1 ratio, (0,0) is the same for both the videoplayer and the bitmap.

then if I click on so (200,200) the bipmap zoom in with this
g.DrawImage(currentFrame, -100 , -100, 897, 712.5); my video Player is of size ( 598 x 475 )

some how this keep the bitmap location (200,200) at the same location for the video Player (200,200). that is a good thing. I want that , so the end user will not get lose . so where they click at will not just jump on them.

and if you click on (200,200) again, it will work just fines. but the moment you click some where else after you zoom , that is not (200,200) then it jump some where wrong.I know ( by hand) if you start at -100 on the video player and go up to 200 on the video player that that is a run of 300 pixels.
and that 300 / 1.5 = 200. 1.5 is my zoom factor.

so I tried this :

  public void Zoom(float zoomFactor, float zoomPointX, float zoomPointY)
        {            VideoPlayerToCurrentFrame(zoomPointX, zoomPointY, out fMouseCurrentFrameX_BeforeZoom, out fMouseCurrentFrameY_BeforeZoom);

            this.zoomPointX = fMouseCurrentFrameX_BeforeZoom;
            this.zoomPointY = fMouseCurrentFrameY_BeforeZoom;

            this.zoomFactor = zoomFactor;
        
            RecalcImage = true;
            fScaleX =  zoomFactor;
            fScaleY = zoomFactor ;
          
        }

   void VideoPlayerToCurrentFrame(float nVideoPlayerX, float nVideoPlayerY, out float fVideoX, out float fVideoY)
        {
            fVideoX = (float)((nVideoPlayerX - imagex) / fScaleX);
            fVideoY = (float)((nVideoPlayerY - imagey) / fScaleY);
        }

and this is so so very close ... but when i click on a new location it jumps a little. and I am not sure why. seem like I am so close to getting this to work, but somehow my equation is still off . idk why...

I thought it could be a rounding issue... but all the values I am using are floats. the only time I am not using a float, is when I 1st get where the user clicks at that comes in as a int but I turned it into a float and keep it as a float the whole time after that .