I am using an integrator class to get a smooth zoom into a specific zone on a map (mine is only slightly modified from the one here with this code). With mine, when a person enters each character of a zip code the points on a map with that code highlight and zoom in a level closer without having to click to enable the zoom (and I don't use faders like the code linked above).

Problem I am having is I need the "bounds" variables to update (line 152) with new mins and max's (of the highlighted points) so that when I call calcZoom() (line 162) the span, target, etc. values update and I get the zoom effect. For some reason though, I can't get accurate new min's and max's of the highlighted points (I tried on line 306 first with test max and min variables but the max's and mins being found are not the maxes and mins of the highlighted/chosen xx and yy variables). I have no idea why.

1. PFont font;
2. String[] data;
3. String typedString = "";      //Why don't I have to say String typedString = new String("");
4. char typedChars[] = new char[5];
5. Place[] places;
6. int totalCount, zip, typedCount, foundCount;
7. int placeCount = 0;
8. int typedPartials[] = new int[6];
9. float Xmin, Xmax, Ymin, Ymax, x, y;
10. float mapX1, mapX2, mapY1, mapY2;
11. float textX, textY;
12. String name;
13. color backgroundColor = color(152, 151, 141);
14. color highlightedColor = color(247, 237, 25);
15. color dormantColor = color(162, 156, 30);
16. //Temporary troubleshooting variables
17. float XminTest;
18. float XmaxTest;
19. float YminTest;
20. float YmaxTest;
21. //Zoom
22. Integrator zoomDepth = new Integrator();
23. Integrator zoomX1;
24. Integrator zoomX2;
25. Integrator zoomY1;
26. Integrator zoomY2;
27. float targetX1[] = new float[6];
28. float targetX2[] = new float[6];
29. float targetY1[] = new float[6];
30. float targetY2[] = new float[6];
31. //Boundary of currently valid points at this typedCount
32. float boundsX1, boundsY1;
33. float boundsX2, boundsY2;
34. PrintWriter file;
35. void setup() {
36.   size(720, 453, P3D);
37.   file = createWriter("file.txt");
38.  
39.   mapX1 = 30.0;
40.   mapX2 = width - mapX1;
41.   mapY1 = 20.0;
42.   mapY2 = height - mapY1;
43.  
44.   font = loadFont("AgencyFB-Reg-48.vlw");
45.   textFont(font);
46.   textMode(SCREEN);
47.   textX = 30;
48.   textY = height - 10;
49.  
50.   readData(data);    //output is Place(zip name x y)
51.  
52.   zoomX1 = new Integrator(Xmin);
53.   zoomX2 = new Integrator(Xmax);
54.   zoomY1 = new Integrator(Ymin);
55.   zoomY2 = new Integrator(Ymax);
56.  
57.   XminTest = width;
58.   XmaxTest = 0;
59.   YminTest = height;
60.   YmaxTest = 0;
61.  
62.   targetX1[0] = Xmin;
63.   targetX2[0] = Xmax;
64.   targetY1[0] = Ymin;
65.   targetY2[0] = Ymax;
66.   //ellipseMode(CENTER);
67.   frameRate(15);
68. }
69. public void draw() {
70.   background(backgroundColor);
71.   updateAnimation();
72.  
73.   println(XminTest+"  "+XmaxTest+"  "+YminTest+"  "+YmaxTest);
74.  
75.   for(int i=0; i<placeCount; i++) {
76.     places[i].draw();
77.   }    
78. }
79. void updateAnimation() {
80.   if(foundCount>0) {
81.     zoomDepth.target(typedCount);
82.   } else {
83.     zoomDepth.target(typedCount-1);
84.   }
85.   zoomDepth.update();
86.  
87.   zoomX1.update();
88.   zoomX2.update();
89.   zoomY1.update();
90.   zoomY2.update();
91. }
92. float TX(float x) {
93.   float xx = map(x, zoomX1.value, zoomX2.value, mapX1, mapX2);
94.   return xx;
95. }
96. float TY(float y) {
97.   float yy = map(y, zoomY1.value, zoomY2.value, mapY2, mapY1);
98.   return yy;
99. }
100. void readData(String[] data) {
101.   data = loadStrings("data/correctCoords.tsv");
102.   parseInfo(data[0]);
103.  
104.   places = new Place[totalCount];
105.   for(int i=1; i<data.length; i++) {    
106.     places[placeCount] = parsePlace(data[i]);
107.     placeCount++;
108.   }
109. }
110. //read header line
111. void parseInfo(String head) {
112.   String[] pieces = split(head, TAB);
113.   totalCount = int(pieces[0]);
114.   Xmin = float(pieces[1]);
115.   Xmax = float(pieces[2]);
116.   Ymin = float(pieces[3]);
117.   Ymax = float(pieces[4]);
118. }
119. Place parsePlace(String pLine) {
120.   String[] pieces = split(pLine, TAB);
121.   zip = int(pieces[0]);
122.   x = float(pieces[1]);
123.   y = float(pieces[2]);
124.   name = pieces[3];
125.   return new Place(zip, name, x, y);
126. }
127. void keyPressed() {
128.   if(key == BACKSPACE || key == DELETE) {
129.     if(typedCount > 0) {
130.       typedCount--;
131.     }
132.     updateTyped();
133.   }
134.   else if(key>='0' && key<='9') {
135.     if(typedCount!=5) {
136.       if(foundCount > 0) {
137.         typedChars[typedCount++] = key;      //why go the the next typed count and ignore the first?
138.       }
139.     }
140.   }
141.   updateTyped();
142. }
143. void updateTyped() {
144.   typedString = new String(typedChars, 0, typedCount);
145.   typedPartials[typedCount] = int(typedString);
146.   for(int j=typedCount-1;j>0; --j){
147.     typedPartials[j] = typedPartials[j+1]/10;
148.   }
149.  
150.   foundCount = 0;
151.  
152.   //set bounds to new mins and maxes
153.   boundsX1 = Xmin;
154.   boundsX2 = Xmax;
155.   boundsY1 = Ymin;
156.   boundsY2 = Ymax;
157.  
158.   for(int i=0; i<placeCount; i++) {
159.     places[i].check();
160.   }
161.  
162.   calcZoom();
163. }
164. void calcZoom() {
165.   if(foundCount != 0) {
166.     float spanX = (boundsX2-boundsX1);
167.     float spanY = (boundsY2-boundsY1);
168.    
169.     float midX = (boundsX1+boundsX2)/2;
170.     float midY = (boundsY1+boundsY2)/2;
171.    
172.     if((spanX != 0) && (spanY != 0)) {
173.       float screenAspect = width/float(height);
174.       float spanAspect = spanX/spanY;
175.      
176.       if(spanAspect>screenAspect) {
177.         spanY = (spanX/width)*height;
178.       }else {
179.         spanX = (spanY/height)*width;
180.       }
181.     } else {
182.       spanX = targetX2[typedCount-1] - targetX1[typedCount-1];
183.       spanY = targetY2[typedCount-1] - targetY1[typedCount-1];
184.     }
185.    
186.     targetX1[typedCount] = midX -spanX/2;
187.     targetX2[typedCount] = midX +spanX/2;
188.     targetY1[typedCount] = midY -spanY/2;
189.     targetY2[typedCount] = midY +spanY/2;
190.    
191.   } else if(typedCount != 0) {
192.     targetX1[typedCount] = targetX1[typedCount-1];
193.     targetX2[typedCount] = targetX2[typedCount-1];
194.     targetY1[typedCount] = targetY1[typedCount-1];
195.     targetY2[typedCount] = targetY2[typedCount-1];
196.   }
197.  
198.   zoomX1.target(targetX1[typedCount]);
199.   zoomX2.target(targetX2[typedCount]);
200.   zoomY1.target(targetY1[typedCount]);
201.   zoomY2.target(targetY2[typedCount]);
202.   println(targetX1[typedCount]);
203.   println(targetX2[typedCount]);
204.   println(targetY1[typedCount]);
205.   println(targetY2[typedCount]);
206.  
207.   zoomX1.set(zoomX1.target);
208.   zoomX2.set(zoomX2.target);
209.   zoomY1.set(zoomY1.target);
210.   zoomY2.set(zoomY2.target);
211. }
212. 
     
213. 
     
214. public class Integrator {
215.   static final float ATTRACTION = 0.2f;  // formerly 0.1f
216.   static final float DAMPING = 0.5f;  // formerly 0.9f
217.   float value = 0;
218.   float vel   = 0;
219.   float accel = 0;
220.   float force = 0;
221.   float mass  = 1;
222.   float damping;
223.   float attraction;
224.  
225.   boolean targeting;
226.   float target;
227.   public Integrator() {
228.     this.value = 0;
229.     this.damping = DAMPING;
230.     this.attraction = ATTRACTION;
231.   }
232.   public Integrator(float value) {
233.     this.value = value;
234.     this.damping = DAMPING;
235.     this.attraction = ATTRACTION;
236.   }
237.   public Integrator(float value, float attraction, float damping) {
238.     this.value = value;
239.     this.damping = damping;
240.     this.attraction = attraction;
241.   }
242.   public void set(float v) {
243.     value = v;
244.   }
245.  
246.   public float get() {
247.     return value;
248.   }
249.  
250.  
251.   public void setAttraction(float a) {
252.     attraction = a;
253.   }
254.  
255.  
256.   public void setDamping(float d) {
257.     damping = d;
258.   }
259.   public boolean update() {
260.     if (targeting) {
261.       force += attraction * (target - value);
262.       accel = force / mass;
263.       vel = (vel + accel) * damping;
264.       value += vel;
265.       force = 0;
266.       return (vel > 0.0001f);
267.     }
268.     return false;
269.   }
270.   public void target(float t) {
271.     targeting = true;
272.     target = t;
273.   }
274. }
275. 
     
276. 
     
277. class Place {
278.   String name;
279.   int zip;
280.   float x;
281.   float y;
282.  
283.   int partial[];
284.   int matchDepth;
285.  
286.   Place(int zip, String name, float x, float y) {
287.     this.name = name;
288.     this.zip = zip;
289.     this.x = x;
290.     this.y = y;
291.    
292.     partial = new int[6];
293.     partial[5] = zip;
294.     partial[4] = partial[5]/10;
295.     partial[3] = partial[4]/10;
296.     partial[2] = partial[3]/10;
297.     partial[1] = partial[2]/10;
298.   } 
299.   void draw() {
300.     color c = dormantColor;
301.     float xx = TX(x);
302.     float yy = TY(y);
303.     if(typedCount != 0) {
304.       if(matchDepth == typedCount) {
305.         c = highlightedColor;
306.         //find new mins and maxs of highlighted places to set as new bounds
307.         if(xx <= XminTest) {XminTest = xx;}
308.         if(xx >= XmaxTest) {XmaxTest = xx;}
309.         if(yy <= YminTest) {YminTest = yy;}
310.         if(yy >= YmaxTest) {YmaxTest = yy;}
311.         //println(xx +"  "+ yy+"  "+ XminTest +"  "+ XmaxTest+"  "+ YminTest+"  "+YmaxTest);
312.       }
313.       else {
314.         c = dormantColor;
315.       }
316.     }
317.     noStroke();
318.     fill(c);
319.     ellipse(xx, yy, 2, 2);
320.     text(typedString, textX, textY);
321.     }
322.  
323.   void check() {
324.     if(typedCount != 0) {
325.       for(int j=typedCount; j>0; --j) {
326.         if(typedPartials[j] == partial[j]) {
327.           matchDepth = j;
328.           break;
329.         }
330.       }
331.     }
332.     if(matchDepth == typedCount) {
333.       foundCount++;
334.     }
335.   }       
336. }

The original values of maxes and mins are correct (line 57-60) and the xx, yy values are correct so why wont lines 306-310 find the max and min of those?

Thank you for the help. I know this is a large chunk of code for a forum question.

McKinnley