If the code isn't too long, perhaps you could show it, so we have a base to play with...
An idea is to compute the vector between the mouse click and a reference coordinate (center, top-left) of the currently zoomed image. You scale the vector with the current scale factor, and deduce the click coordinate in the scale 1:1. Then you compute the scale and translate to the compute coordinate. (Sounds confusing, no?)

Unfortunately, I can't share the code, as it's proprietary for a client.

That being said, the concept is very simple:  imagine you want to zoom in or out with each click, and you want the zoom to be centered where the click is.

I'll investigate the scaled vector as a possibility.  Thanks!

There are two different things at play here. One is the center position of the image/shape and two is the effect of the zoom level. If the imageMode is centered, then for a given center point, the zoom will always be correct. Because the center point (focus point) remains the same whether the zoom is 1, 10 or 100). So that is useful, the second thing is the zoom and how it affects changes in the translation. The first effect is on the main translation, the bigger the image, the bigger the needed translation to end up at a certain point. For an image 10 times as big you need to move 10 times further to end up at the same point. The second effect is on the additional translation, which at zoom level 1, is the mouse position from the center. At higher zoom levels it still is the mouse position from the center, but divided by the zoom level.

To summarize:
- use a centered image/shape
- account for higher translation with regard to the zoom level
- incrementally change the translation based on the zoom level

Below is a code example which applies these suggestions. The left mouse button centers on this clicked position and also zooms in 50%. The mouse wheel allows to zoom in and out fast at the same center point. The right mouse button resets the view. As always, there are multiple ways of doing it, so I hope this helps you get where you want to be.

1. PImage myImage;
2. float zoom = 1;
3. float x,y;
4. 
   
5. void setup() {
6.   size(1200,800);
7.   myImage = loadImage("yourImageName.jpg");
8.   addMouseWheelListener(
9.     new java.awt.event.MouseWheelListener() {
10.       public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt)
11.       { mouseWheel(evt.getWheelRotation()); }
12.     }
13.   );
14. }
15. 
    
16. void draw() {
17.   background(0);
18.   pushMatrix();
19.   translate(width/2 + x*zoom, height/2 + y*zoom);
20.   scale(zoom);
21.   imageMode(CENTER);
22.   image(myImage,0,0);
23.   popMatrix();
24.   stroke(255);
25.   line(width/2,0,width/2,height);
26.   line(0,height/2,width,height/2);
27. }
28. 
    
29. void mousePressed() {
30.   if (mouseButton == LEFT) {
31.     x += (width/2 - mouseX)/zoom;
32.     y += (height/2 - mouseY)/zoom;
33.     zoom *= 1.5;
34.   } else {
35.     zoom = 1;
36.     x = 0;
37.     y = 0;
38.   }
39. }
40. 
    
41. void mouseWheel(int delta) {
42.   if (delta == -1) { zoom *= 1.25; }
43.   else if ((delta == 1) && (zoom > 1.25)) { zoom *= 1/1.25; }
44. }

1. //given a screen coordinate, tell us where it is on the image
2. PVector screenToImage(int x, int y) {
3.   return new PVector((x - imageX) / initialScale, (y - imageY) / initialScale);
4. }
6. //given a point on our main image, where is it on the screen?
7. PVector imageToScreen(int x, int y) {
8.   return new PVector((x * initialScale) + imageX, (y * initialScale) + imageY);
9. }

1.  //draw main image
2. image(img,imageX,imageY, img.width * initialScale, img.height * initialScale);

1. 
   void mouseWheel(int delta) {
2.      //get the spot on the image that our mouse is on
3.      PVector zoomImagePos = screenToImage(mouseX, mouseY);
4.      //get the spot on the screen that our mouse is on
5.      PVector zoomScreenPos = new PVector(mouseX, mouseY);
7.      int lastScale = initialScale;
8.     
        if ( delta > 0 ) {
9.        initialScale--;
10.      } else {
11.        initialScale++;
12.      }
13.       //constrain zoom
14.       if (initialScale > maxZoom) initialScale = maxZoom;
15.       if (initialScale < 1) initialScale = 1;
17.       //we want our original image point to be moved to the same spot on the screen that it was
18.       //where is that image point on the screen now?
19.       PVector newPos = imageToScreen((int)zoomImagePos.x, (int)zoomImagePos.y);
20.  
          //difference between original screen pos and current screen pos
21.       int xDif = (int)(newPos.x - zoomScreenPos.x);
22.       int yDif = (int)(newPos.y - zoomScreenPos.y);
23.       
          //we need to move imageX/Y by this amount:
24.       imageX = imageX - xDif;
25.       imageY = imageY - yDif;
26. }