Debian Codegraph @

libsrc/idi/cidi/x11/iir.c

raw
1 /* @(#)iir.c 19.1 (ESO-DMD) 02/25/03 13:54:49 */
2 /*===========================================================================
3 Copyright (C) 1995 European Southern Observatory (ESO)
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as
7 published by the Free Software Foundation; either version 2 of
8 the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public
16 License along with this program; if not, write to the Free
17 Software Foundation, Inc., 675 Massachusetts Ave, Cambridge,
18 MA 02139, USA.
19
20 Correspondence concerning ESO-MIDAS should be addressed as follows:
21 Internet e-mail: [email protected]
22 Postal address: European Southern Observatory
23 Data Management Division
24 Karl-Schwarzschild-Strasse 2
25 D 85748 Garching bei Muenchen
26 GERMANY
27 ===========================================================================*/
28
29 /* ----------------------------------------------------------------- */
30 /* --------- IIR -------------------------------------------------- */
31
32 /* !! all roi coords are relative to the associated memory !! */
33 /* !! (or to the ididev in case of memory = -1) !! */
34 /* !! (0,0 = bottom left) !! */
35 /* ----------------------------------------------------------------- */
36
37 /* file IIR.C : contains the following routines
38 *
39 * IIRINR_C : Initialize Rectangular Region of Interest;
40 * IIRRRI_C : Read Rectangular Region of Interest Position;
41 * IIRWRI_C : Write Rectangular Region of Interest Position;
42 *
43 * IICINR_C : Initialize Circular Region of Interest;
44 * IICRRI_C : Read Circular Region of Interest Position;
45 * IICWRI_C : Write Circular Region of Interest Position;
46 *
47 * IIRSRV_C : Set Region of Interest Visibility;
48 *
49 ***********************************************************************
50 * V 1.1 871201: P. Santin - Trieste Astronomical Observatory *
51 * V 2.0 881219: K. Banse - ESO Garching *
52
53 010515 last modif
54
55 ***********************************************************************
56 */
57
58
59 # include <idi.h>
60 # include <idistruct.h>
61 # include <proto_idi.h>
62
63 static int dxsize, dysize;
64
65 static ROI_DATA *roi;
66 /*
67
68 */
69
70
71 /************************************************************************
72 * IIRINR_C routine : initialize rectangular region of interest *
73 * *
74 * synopsis IIRINR_C (display , memid , roicol , roixmin , roiymin , *
75 * roixmax , roiymax , roiid); *
76 * *
77 * int display; input display identifier *
78 * int memid; input memory identifier *
79 * int roicol; input roi color *
80 * int roixmin; input X min *
81 * int roiymin; input Y min *
82 * int roixmax; input X max *
83 * int roiymax; input Y max *
84 * int roiid; output ROI id *
85 ************************************************************************/
86
87 int IIRINR_C (display , memid , roicol , roixmin , roiymin ,
88 roixmax , roiymax , roiid)
89
90 int display , *roiid , memid , roicol;
91 int roixmin , roiymin , roixmax , roiymax;
92
93 {
94
95 if (ididev[display].opened == 0) return(DEVNOTOP);
96
97 *roiid = 0;
98 roi = ididev[display].roi; /* we only use one ROI */
99
100 /* store ROI parameters */
101
102 roi->col = roicol;
103 roi->sh = 0;
104 roi->vis = 0;
105
106 /* write ROI */
107 if ((roixmin >= 0) && (roiymin >= 0))
108 {
109 roi->xmin = roixmin;
110 roi->ymin = roiymin;
111 roi->xmax = roixmax;
112 roi->ymax = roiymax;
113 }
114
115 return(II_SUCCESS);
116 }
117 /*
118
119 */
120
121 /************************************************************************
122 * IIRSRV_C routine : set region of interest visibility *
123 * *
124 * synopsis IIRSRV_C (display , roiid , vis); *
125 * *
126 * int display; input display identifier *
127 * int roiid; input ROI id *
128 * int vis; input visibility [1 / 0] *
129 ************************************************************************/
130
131 int IIRSRV_C (display , roiid , vis)
132
133 int display , roiid , vis;
134
135 {
136
137 int flag;
138
139
140 if (ididev[display].opened == 0) return(DEVNOTOP);
141
142 roi = ididev[display].roi;
143 if (roi->sh == -1) return(ROINOTDEF);
144 if (roi->vis == vis) return(II_SUCCESS);
145
146 dysize = ididev[display].ysize - 1;
147
148 if (vis == 0) /* so roi->vis currently 1 */
149 flag = 2;
150 else /* so roi->vis currently 0 */
151 flag = 0;
152
153 if (roi->sh == 0) /* rectangle */
154 draw_rroi(display,flag,dysize,roi->xmin,roi->ymin,
155 roi->xmax,roi->ymax,roi->col);
156 else
157 { /* circle */
158 int xcen, ycen;
159
160 xcen = roi->xmin + roi->radiusi;
161 ycen = roi->ymin + roi->radiusi;
162
163 draw_croi(display,flag,dysize,xcen,ycen,
164 roi->radiusi,roi->radiusm,roi->radiuso,roi->col);
165 }
166
167 roi->vis = vis; /* update roi->vis accordingly */
168
169 return(II_SUCCESS);
170 }
171
172 /*
173
174 */
175 /************************************************************************
176 * IIRRRI_C routine : read region of interest position *
177 * *
178 * synopsis IIRRRI_C (display , inmemid , roiid , roixmin , roiymin , *
179 * roixmax , roiymax , outmemid); *
180 * *
181 * int display; input display identifier *
182 * int inmemid; input input memory identifier *
183 * int roiid; input ROI id *
184 * int *roixmin; output X min *
185 * int *roiymin; output Y min *
186 * int *roixmax; output X max *
187 * int *roiymax; output Y max *
188 * int *outmemid; output output memory identifier *
189 ************************************************************************/
190
191 int IIRRRI_C (display , inmemid , roiid , roixmin , roiymin , roixmax ,
192 roiymax , outmemid)
193
194 int display , roiid , inmemid , *outmemid;
195 int *roixmin , *roiymin , *roixmax , *roiymax;
196
197 {
198 int i;
199
200 CONF_DATA *conf;
201 MEM_DATA *mem;
202
203 if (ididev[display].opened == 0) return(DEVNOTOP);
204
205 conf = ididev [display].confptr;
206 roi = ididev[display].roi;
207 if (roi->sh == -1) return(ROINOTDEF);
208
209 *roixmin = roi->xmin;
210 *roiymin = roi->ymin;
211 *roixmax = roi->xmax;
212 *roiymax = roi->ymax;
213
214 /* search current memory for cursor */
215
216 *outmemid = 0;
217 for (i=0; i<conf->nmem; i++)
218 {
219 mem = conf->memory[i];
220 if (mem->visibility == 1)
221 {
222 *outmemid = i;
223 break;
224 }
225 }
226
227 return(II_SUCCESS);
228 }
229 /*
230
231 */
232
233 /************************************************************************
234 * IIRWRI_C routine : write region of interest position *
235 * *
236 * synopsis IIRWRI_C (display , memid , roiid , roixmin , roiymin , *
237 * roixmax , roiymax); *
238 * *
239 * int display; input display identifier *
240 * int memid; input memory identifier *
241 * int roiid; input ROI id *
242 * int roixmin; input X min *
243 * int roiymin; input Y min *
244 * int roixmax; input X max *
245 * int roiymax; input Y max *
246 ************************************************************************/
247
248 int IIRWRI_C (display, memid, roiid, roixmin, roiymin, roixmax, roiymax)
249
250 int display , memid , roiid;
251 int roixmin , roiymin , roixmax , roiymax;
252
253 {
254
255 if (ididev[display].opened == 0) return(DEVNOTOP);
256
257 roi = ididev[display].roi; /* we only use one ROI */
258
259 dxsize = ididev[display].xsize - 1;
260 dysize = ididev[display].ysize - 1;
261
262 if (roixmin < 0)
263 roixmin = 0;
264 else
265 {
266 if (roixmin > dxsize) roixmin = dxsize;
267 }
268
269 if (roiymin < 0)
270 roiymin = 0;
271 else
272 {
273 if (roiymin > dysize) roiymin = dysize;
274 }
275
276 if (roixmax < 0)
277 roixmax = 0;
278 else
279 {
280 if (roixmax > dxsize) roixmax = dxsize;
281 }
282
283 if (roiymax < 0)
284 roiymax = 0;
285 else
286 {
287 if (roiymax > dxsize) roiymax = dysize;
288 }
289
290 roi->xmin = roixmin;
291 roi->ymin = roiymin;
292 roi->xmax = roixmax;
293 roi->ymax = roiymax;
294
295 return(II_SUCCESS);
296 }
297
298
299 /*
300
301 */
302
303 /************************************************************************
304 * IICINR_C routine : initialize circular region of interest *
305 * *
306 * synopsis IICINR_C (display, memid, roicol, roixcen, roiycen, *
307 * radiusi, radiusm, radiuso, roiid); *
308 * *
309 * int display; input display identifier *
310 * int memid; input memory identifier *
311 * int roicol; input roi color *
312 * int roixcen; input X cen *
313 * int roiycen; input Y cen *
314 * int radiusi; input inner radius *
315 * int radiusm; input middle radius (maybe = 0) *
316 * int radiuso; input outer radius (maybe = 0) *
317 * int roiid; output ROI id (not used - always 0) *
318 ************************************************************************/
319
320 int IICINR_C (display, memid, roicol, roixcen, roiycen,
321 radiusi, radiusm, radiuso, roiid)
322
323 int display, *roiid, memid, roicol;
324 int roixcen, roiycen , radiusi, radiusm, radiuso;
325
326 {
327
328 int xmin, ymin;
329
330
331
332 if (ididev[display].opened == 0) return(DEVNOTOP);
333
334 *roiid = 0;
335 roi = ididev[display].roi; /* we only use one ROI */
336
337
338 roi->col = roicol; /* store ROI parameters */
339 roi->sh = 1; /* indicate circle */
340 roi->vis = 0;
341
342 /* write ROI */
343 if (radiusi < 1) return (BADINPUT);
344 roi->radiusi = radiusi;
345
346 if (radiusm < 1)
347 roi->radiusm = 0;
348 else
349 {
350 if (radiusm < radiusi)
351 roi->radiusm = radiusi;
352 else
353 roi->radiusm = radiusm;
354 }
355
356 if (radiuso < 1)
357 roi->radiuso = 0;
358 else
359 {
360 if (roi->radiusm > 0)
361 {
362 if (radiuso < roi->radiusm)
363 roi->radiuso = roi->radiusm;
364 else
365 roi->radiuso = radiuso;
366 }
367 else
368 {
369 if (radiuso < roi->radiusi)
370 roi->radiuso = roi->radiusi;
371 else
372 roi->radiuso = radiuso;
373 }
374 }
375
376 if ((roixcen >= 0) && (roiycen >= 0))
377 {
378 dxsize = ididev[display].xsize - 1;
379 dysize = ididev[display].ysize - 1;
380
381 xmin = roixcen - roi->radiusi;
382 if (xmin < 0)
383 {
384 roixcen = roi->radiusi;
385 if (roixcen > dxsize) roixcen = dxsize/2;
386 }
387 else
388 {
389 xmin = roixcen + roi->radiusi;
390 if (xmin > dxsize) roixcen = dxsize - roi->radiusi;
391 if (roixcen < 0) roixcen = dxsize/2;
392 }
393
394 ymin = roiycen - roi->radiusi;
395 if (ymin < 0)
396 {
397 roiycen = roi->radiusi;
398 if (roiycen > dysize) roiycen = dysize/2;
399 }
400 else
401 {
402 ymin = roiycen + roi->radiusi;
403 if (ymin > dysize) roiycen = dysize - roi->radiusi;
404 if (roiycen < 0) roiycen = dysize/2;
405 }
406
407 roi->xmin = roixcen;
408 roi->ymin = roiycen;
409 }
410
411 roi->xmax = radiusi; /* start with inner radius as ref. */
412 loc_mod(display,0,-14); /* init `radiusno' in idiutil2.c */
413
414 return(II_SUCCESS);
415 }
416
417 /*
418
419 */
420
421 /************************************************************************
422 * IICRRI_C routine : read region of interest position *
423 * *
424 * synopsis IICRRI_C (display, inmemid, roiid, roixcen, roiycen, *
425 * radiusi, radiusm, radiuso, outmemid) *
426 * *
427 * int display; input display identifier *
428 * int inmemid; input input memory identifier *
429 * int roiid; input ROI id *
430 * int *roixcen; output X cen *
431 * int *roiycen; output Y cen *
432 * int *radiusi; output radiusi *
433 * int *radiusm; output radiusm *
434 * int *radiuso; output radiuso *
435 * int *outmemid; output output memory identifier *
436 ************************************************************************/
437
438 int IICRRI_C (display, inmemid, roiid, roixcen, roiycen,
439 radiusi, radiusm, radiuso, outmemid)
440
441 int display , roiid , inmemid , *outmemid;
442 int *roixcen , *roiycen , *radiusi, *radiusm, *radiuso;
443
444 {
445 int i;
446
447 CONF_DATA *conf;
448 MEM_DATA *mem;
449
450 if (ididev[display].opened == 0) return(DEVNOTOP);
451
452 conf = ididev [display].confptr;
453 roi = ididev[display].roi;
454 if (roi->sh == -1) return(ROINOTDEF);
455
456 *roixcen = roi->xmin;
457 *roiycen = roi->ymin;
458 *radiusi = roi->radiusi;
459 *radiusm = roi->radiusm;
460 *radiuso = roi->radiuso;
461
462
463 /* search current memory for cursor */
464
465 *outmemid = 0;
466 for (i=0; i<conf->nmem; i++)
467 {
468 mem = conf->memory[i];
469 if (mem->visibility == 1)
470 {
471 *outmemid = i;
472 break;
473 }
474 }
475
476 return(II_SUCCESS);
477 }
478 /*
479
480 */
481
482 /************************************************************************
483 * IICWRI_C routine : write region of interest position *
484 * *
485 * synopsis IICWRI_C (display, memid, roiid, roixcen, roiycen, *
486 * radiusi, radiusm, radiuso) *
487 * *
488 * int display; input display identifier *
489 * int memid; input memory identifier *
490 * int roiid; input ROI id *
491 * int roixcen; input X cen *
492 * int roiycen; input Y cen *
493 * int radiusi; input inner radius *
494 * int radiusm; input middle radius (maybe = 0) *
495 * int radiuso; input outer radius (maybe = 0) *
496 ************************************************************************/
497
498 int IICWRI_C (display, memid, roiid, roixcen, roiycen,
499 radiusi, radiusm, radiuso)
500
501 int display, memid, roiid;
502 int roixcen, roiycen, radiusi, radiusm, radiuso;
503
504 {
505 int xmin, ymin;
506
507
508
509 if (ididev[display].opened == 0) return(DEVNOTOP);
510
511 roi = ididev[display].roi; /* we only use one ROI */
512
513 if (radiusi < 1) return (BADINPUT);
514 roi->radiusi = radiusi;
515
516 if (radiusm < 1)
517 roi->radiusm = 0;
518 else
519 {
520 if (radiusm < radiusi)
521 roi->radiusm = radiusi;
522 else
523 roi->radiusm = radiusm;
524 }
525
526 if (radiuso < 1)
527 roi->radiuso = 0;
528 else
529 {
530 if (roi->radiusm > 0)
531 {
532 if (radiuso < roi->radiusm)
533 roi->radiuso = roi->radiusm;
534 else
535 roi->radiuso = radiuso;
536 }
537 else
538 {
539 if (radiuso < roi->radiusi)
540 roi->radiuso = roi->radiusi;
541 else
542 roi->radiuso = radiuso;
543 }
544 }
545
546 if ((roixcen >= 0) && (roiycen >= 0))
547 {
548 dxsize = ididev[display].xsize - 1;
549 dysize = ididev[display].ysize - 1;
550
551 xmin = roixcen - roi->radiusi;
552 if (xmin < 0)
553 {
554 roixcen = roi->radiusi;
555 if (roixcen > dxsize) roixcen = dxsize/2;
556 }
557 else
558 {
559 xmin = roixcen + roi->radiusi;
560 if (xmin > dxsize) roixcen = dxsize - roi->radiusi;
561 if (roixcen < 0) roixcen = dxsize/2;
562 }
563
564 ymin = roiycen - roi->radiusi;
565 if (ymin < 0)
566 {
567 roiycen = roi->radiusi;
568 if (roiycen > dysize) roiycen = dysize/2;
569 }
570 else
571 {
572 ymin = roiycen + roi->radiusi;
573 if (ymin > dysize) roiycen = dysize - roi->radiusi;
574 if (roiycen < 0) roiycen = dysize/2;
575 }
576
577 roi->xmin = roixcen;
578 roi->ymin = roiycen;
579 }
580
581 roi->xmax = roi->radiusi;
582 loc_mod(display,0,-14); /* set initial distance */
583
584 return(II_SUCCESS);
585 }