Annotation of OpenXM_contrib2/asir2018/plot/if.c, Revision 1.2
1.1 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.2 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2018/plot/if.c,v 1.1 2018/09/19 05:45:08 noro Exp $
1.1 noro 49: */
50: #include "ca.h"
51: #include "parse.h"
52: #include "ox.h"
53: #include "ifplot.h"
54:
55: #if defined(INTERVAL)
56: // Time message and func
57: #include <sys/types.h>
58: #include <sys/resource.h>
59: #include <sys/time.h>
60:
61: static struct oEGT ltime;
62: static double r0;
63: double get_rtime();
64: void MSGdraw(char *);
65: char msg[128];
66: #if defined(ITV_TIME_CHECK)
67: void tstart()
68: {
69: get_eg(<ime);
70: r0=get_rtime();
71: }
72:
73: void tstop(struct canvas *can)
74: {
75: struct oEGT egt1;
76: double e, g, r;
77: char ts[100];
78: void popdown_warning();
79: Widget warnshell,warndialog;
80:
81: get_eg(&egt1);
82: e=egt1.exectime - ltime.exectime;
83: g=egt1.gctime - ltime.gctime;
84: r=get_rtime() - r0;
85: sprintf(ts,"(%8.6f + gc %8.6f) total %8.6f \n",e,g,r);
86: create_popup(can->shell,"Message",&ts,&warnshell,&warndialog);
87: XawDialogAddButton(warndialog,"OK",popdown_warning,warnshell);
88: XtPopup(warnshell,XtGrabNone);
89: SetWM_Proto(warnshell);
90: }
91: #else
92: #define tstart()
93: #define tstop(a)
94: #endif
95: #endif
96:
97: extern JMP_BUF ox_env;
98:
99: int open_canvas(NODE arg){
100: int id;
101: struct canvas *can;
102: LIST wsize;
103: STRING wname;
104:
105: wsize=(LIST)ARG0(arg);
106: wname=(STRING)ARG1(arg);
107: id=search_canvas();
108: can=canvas[id];
109: can->mode=modeNO(INTERACTIVE);
110: if(!wsize){
111: can->width=DEFAULTWIDTH;
112: can->height=DEFAULTHEIGHT;
113: } else {
1.2 ! noro 114: can->width=ZTOS((Q)BDY(BDY(wsize)));
! 115: can->height=ZTOS((Q)BDY(NEXT(BDY(wsize))));
1.1 noro 116: }
117: if(wname)can->wname=BDY(wname);
118: else can->wname="";
119: create_canvas(can);
120: return id;
121: }
122:
123: int plot(NODE arg,int fn){
124: int id;
125: NODE n;
126: struct canvas *can;
127: P formula;
128: LIST xrange,yrange,zrange,wsize;
129: STRING wname;
130: V v;
131: Real r;
132: double rr;
133:
134: formula=(P)ARG0(arg);
135: xrange=(LIST)ARG1(arg);
136: yrange=(LIST)ARG2(arg);
137: zrange=(LIST)ARG3(arg);
138: wsize=(LIST)ARG4(arg);
139: wname=(STRING)ARG5(arg);
140: can=canvas[id=search_canvas()];
141: if(xrange){
142: n=BDY(xrange);can->vx=VR((P)BDY(n));n=NEXT(n);
143: can->qxmin=(Q)BDY(n);n=NEXT(n);can->qxmax=(Q)BDY(n);
144: can->xmin=ToReal(can->qxmin);can->xmax=ToReal(can->qxmax);
145: }
146: if(yrange){
147: n=BDY(yrange);can->vy=VR((P)BDY(n));n=NEXT(n);
148: can->qymin=(Q)BDY(n);n=NEXT(n);can->qymax=(Q)BDY(n);
149: can->ymin=ToReal(can->qymin);can->ymax=ToReal(can->qymax);
150: } else if ( !formula || NUM(formula) ) {
151: devalr(CO,(Obj)formula,(Obj *)&r); rr = ToReal(r);
152: can->ymin=rr-1; can->ymax=rr+1;
153: }
154: can->mode=fn;
155: if(zrange){
156: n=NEXT(BDY(zrange));
157: can->zmin=ToReal(BDY(n));
158: n=NEXT(n);can->zmax=ToReal(BDY(n));
159: n=NEXT(n);
1.2 ! noro 160: if(can->mode==modeNO(CONPLOT))can->nzstep=n?ZTOS((Q)BDY(n)):MAXGC;
1.1 noro 161: else {
162: can->vx=VR((P)BDY(BDY(zrange)));
1.2 ! noro 163: can->nzstep=n?ZTOS((Q)BDY(n)):DEFAULTPOLARSTEP;
1.1 noro 164: }
165: }
166: if(!wsize){
167: can->width=DEFAULTWIDTH;
168: can->height=DEFAULTHEIGHT;
169: } else {
1.2 ! noro 170: can->width=ZTOS((Q)BDY(BDY(wsize)));
! 171: can->height=ZTOS((Q)BDY(NEXT(BDY(wsize))));
1.1 noro 172: }
173: if(wname) can->wname=BDY(wname);
174: else can->wname="";
175: can->formula=formula;
176: if(can->mode==modeNO(PLOT)){
177: //plot
1.2 ! noro 178: can->prec=argc(arg)==7 ? ZTOS((Q)ARG6(arg)) : 0;
1.1 noro 179: plotcalc(can);
180: create_canvas(can);
181: plot_print(display,can);
182: } else if(can->mode==modeNO(POLARPLOT)){
183: polarcalc(can);
184: create_canvas(can);
185: plot_print(display,can);
186: } else {
187: create_canvas(can);
188: ifplotmain(can);
189: }
190: copy_to_canvas(can);
191: return id;
192: }
193:
194: void ifplotmain(struct canvas *can){
195: int i,width,height;
196: double ** tabe;
197:
198: width=can->width;height=can->height;
199: tabe=(double **)ALLOCA((width+1)*sizeof(double *));
200: for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
201: define_cursor(can->window,runningcur);
202: set_busy(can); set_selection();
203: calc(tabe,can,0);
204: if_print(display,tabe,can);
205: reset_selection(); reset_busy(can);
206: define_cursor(can->window,normalcur);
207: }
208:
209: int memory_plot(NODE arg,LIST *bytes){
210: NODE n;
211: struct canvas tmp_can;
212: struct canvas *can;
213: P formula;
214: LIST xrange,yrange,zrange,wsize;
215: int width,height;
216: double **tabe;
217: int i;
218: BYTEARRAY barray;
219: Z qw,qh,prec;
220:
221: formula=(P)ARG0(arg);
222: xrange=(LIST)ARG1(arg);
223: yrange=(LIST)ARG2(arg);
224: zrange=(LIST)ARG3(arg);
225: wsize=(LIST)ARG4(arg);
226:
227: bzero((char *)&tmp_can,sizeof(tmp_can));
228: can=&tmp_can;
229: n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
230: can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
231: can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
232: if( yrange ){
233: n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
234: can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
235: can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
236: if( zrange ){
237: n=NEXT(BDY(zrange));
238: can->zmin=ToReal(BDY(n)); n=NEXT(n); can->zmax=ToReal(BDY(n));
239: n=NEXT(n);
1.2 ! noro 240: if(n) can->nzstep=ZTOS((Q)BDY(n));
1.1 noro 241: else can->nzstep=MAXGC;
242: can->mode=modeNO(CONPLOT);
243: } else
244: can->mode=modeNO(IFPLOT);
245: } else
246: can->mode=modeNO(PLOT);
247: if( !wsize ){
248: can->width=DEFAULTWIDTH; can->height=DEFAULTHEIGHT;
249: } else {
1.2 ! noro 250: can->width=ZTOS((Q)BDY(BDY(wsize)));
! 251: can->height=ZTOS((Q)BDY(NEXT(BDY(wsize))));
1.1 noro 252: }
253: can->wname="";
254: can->formula=formula;
255: if( can->mode==modeNO(PLOT)){
1.2 ! noro 256: can->prec = argc(arg)==6 ? ZTOS((Q)ARG5(arg)) : 0;
1.1 noro 257: plotcalc(can);
258: memory_print(can,&barray);
1.2 ! noro 259: STOZ(can->width,qw); STOZ(can->height,qh);
1.1 noro 260: n=mknode(3,qw,qh,barray);
261: MKLIST(*bytes,n);
262: } else {
263: width=can->width; height=can->height;
264: tabe=(double **)ALLOCA(width*sizeof(double *));
265: for( i=0; i<width; i++ )
266: tabe[i]=(double *)ALLOCA(height*sizeof(double));
267: calc(tabe,can,1);
268: memory_if_print(tabe,can,&barray);
1.2 ! noro 269: STOZ(width,qw); STOZ(height,qh);
1.1 noro 270: n=mknode(3,qw,qh,barray);
271: MKLIST(*bytes,n);
272: }
273: return 0;
274: }
275:
276: int plotover(NODE arg){
277: int id;
278: unsigned int orgcolor;
279: P formula;
280: struct canvas *can;
281: VL vl,vl0;
282:
1.2 ! noro 283: id=ZTOS((Q)ARG0(arg));
1.1 noro 284: formula=(P)ARG1(arg);
285: can=canvas[id];
286: orgcolor=can->color;
1.2 ! noro 287: if(argc(arg)==3) can->color=ZTOS((Q)ARG2(arg));
1.1 noro 288: else can->color=0;
289: get_vars_recursive((Obj)formula,&vl);
290: for(vl0=vl;vl0;vl0=NEXT(vl0))
291: if(vl0->v->attr==(pointer)V_IND)
292: if(vl->v!=can->vx && vl->v!=can->vy)return -1;
293: #if !defined(VISUAL) && !defined(__MINGW32__)
294: set_drawcolor(can->color);
295: #endif
296: current_can=can;
297: can->formula=formula;
298: if(can->mode==modeNO(PLOT)){
1.2 ! noro 299: can->prec = argc(arg)==3 ? ZTOS((Q)ARG2(arg)) : 0;
1.1 noro 300: plotcalc(can);
301: plot_print(display,can);
302: } else ifplotmain(can);
303: copy_to_canvas(can);
304: can->color=orgcolor;
305: #if !defined(VISUAL) && !defined(__MINGW32__)
306: set_drawcolor(can->color);
307: #endif
308: return id;
309: }
310:
311: int drawcircle(NODE arg){
312: #if !defined(VISUAL) && !defined(__MINGW32__)
313: int id,index,wx,wy,wr;
314: unsigned int c;
315: pointer ptr;
316: Q ret;
317: LIST xyr;
318: Obj x,y,r;
319: struct canvas *can;
320:
1.2 ! noro 321: index=ZTOS((Q)ARG0(arg));
1.1 noro 322: xyr=(LIST)ARG1(arg);
323: x=(Obj)ARG0(BDY(xyr)); y=(Obj)ARG1(BDY(xyr)); r=(Obj)ARG2(BDY(xyr));
1.2 ! noro 324: c=ZTOS((Q)ARG2(arg));
1.1 noro 325: can=canvas[index];
326: if(!can->window)return -1;
327: else {
328: current_can=can;
329: set_drawcolor(c);
330: wx=(ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin);
331: wy=(can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin);
332: wr=ToReal(r);
333: XFillArc(display,can->pix,cdrawGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64);
334: copy_to_canvas(can);
335: set_drawcolor(can->color);
336: return index;
337: }
338: #endif
339: }
340:
341: int draw_obj(NODE arg){
342: int index,x,y,u,v,len,r;
343: unsigned int color;
344: NODE obj,n;
345: RealVect *vect;
346: struct canvas *can;
347:
1.2 ! noro 348: index=ZTOS((Q)ARG0(arg));
1.1 noro 349: can=canvas[index];
350: if(!can && closed_canvas[index]){
351: canvas[index]=closed_canvas[index];
352: closed_canvas[index]=0;
353: can=canvas[index];
354: popup_canvas(index);
355: current_can=can;
356: } else if(!can||(can && !can->window)){
357: set_lasterror("draw_obj : canvas does not exist");
358: return -1;
359: }
360:
361: obj=BDY((LIST)ARG1(arg));
1.2 ! noro 362: if(argc(arg)== 3) color=ZTOS((Q)ARG2(arg));
1.1 noro 363: else color=0; // black
364: switch(len=length(obj)){
365: case 2: // point
366: x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
367: draw_point(display,can,x,y,color);
368: MKRVECT3(vect,x,y,color); MKNODE(n,vect,can->history);
369: can->history=n;
370: break;
371: case 3: // circle
372: x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
373: r=(int)ToReal((Q)ARG2(obj));
374: MKRVECT4(vect,x,y,r,color); MKNODE(n,vect,can->history);
375: can->history=n;
376: break;
377: case 4: // line
378: x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
379: u=(int)ToReal((Q)ARG2(obj)); v=(int)ToReal((Q)ARG3(obj));
380: draw_line(display,can,x,y,u,v,color);
381: MKRVECT5(vect,x,y,u,v,color); MKNODE(n,vect,can->history);
382: can->history=n;
383: break;
384: default:
385: set_lasterror("draw_obj : invalid request");
386: return -1;
387: }
388: #if !defined(VISUAL) && !defined(__MINGW32__)
389: set_drawcolor(can->color);
390: #endif
391: return 0;
392: }
393:
394: int draw_string(NODE arg){
395: int index,x,y;
396: unsigned int color;
397: char *str;
398: NODE pos;
399: struct canvas *can;
400:
1.2 ! noro 401: index=ZTOS((Q)ARG0(arg));
1.1 noro 402: can=canvas[index];
403: if(!can && closed_canvas[index]){
404: canvas[index]=closed_canvas[index];
405: closed_canvas[index]=0;
406: can=canvas[index];
407: popup_canvas(index);
408: current_can=can;
409: } else if(!can||(can && !can->window)){
410: set_lasterror("draw_obj : canvas does not exist");
411: return -1;
412: }
413:
414: pos=BDY((LIST)ARG1(arg));
415: str=BDY((STRING)ARG2(arg));
1.2 ! noro 416: if(argc(arg)==4)color=ZTOS((Q)ARG3(arg));
1.1 noro 417: else color=0; // black
418: x=(int)ToReal((Q)ARG0(pos));
419: y=(int)ToReal((Q)ARG1(pos));
420: draw_character_string(display,can,x,y,str,color);
421: #if !defined(VISUAL) && !defined(__MINGW32__)
422: set_drawcolor(can->color);
423: #endif
424: return 0;
425: }
426:
427: int clear_canvas(NODE arg){
428: int index;
429: struct canvas *can;
430:
1.2 ! noro 431: index=ZTOS((Q)ARG0(arg));
1.1 noro 432: can=canvas[index];
433: if(!can||!can->window) return -1;
434: clear_pixmap(can);
435: copy_to_canvas(can);
436: // clear the history
437: can->history=0;
438: return 0;
439: }
440:
441: #define RealtoDbl(r) ((r)?BDY(r):0.0)
442:
443: int arrayplot(NODE arg){
444: int id,ix,w,h;
445: VECT array;
446: LIST xrange,wsize;
447: char *wname;
448: NODE n;
449: double ymax,ymin,dy,xstep;
450: Real *tab;
451: struct canvas *can;
452: POINT *pa;
453:
454: array=(VECT)ARG0(arg);
455: xrange=(LIST)ARG1(arg);
456: can=canvas[id=search_canvas()];
457: n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
458: can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
459: can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
460: if(!wsize){
461: can->width=DEFAULTWIDTH;
462: can->height=DEFAULTHEIGHT;
463: } else {
1.2 ! noro 464: can->width=ZTOS((Q)BDY(BDY(wsize)));
! 465: can->height=ZTOS((Q)BDY(NEXT(BDY(wsize))));
1.1 noro 466: }
467: can->wname=wname; can->formula=0; can->mode=modeNO(PLOT);
468: create_canvas(can);
469: w=array->len;
470: h=can->height;
471: tab=(Real *)BDY(array);
472: if(can->ymax==can->ymin){
473: for(ymax=ymin=RealtoDbl(tab[0]),ix=1; ix<w; ix++){
474: if(RealtoDbl(tab[ix])>ymax)ymax=RealtoDbl(tab[ix]);
475: if(RealtoDbl(tab[ix])<ymin)ymin=RealtoDbl(tab[ix]);
476: }
477: can->ymax=ymax;
478: can->ymin=ymin;
479: } else {
480: ymax=can->ymax;
481: ymin=can->ymin;
482: }
483: dy=ymax-ymin;
484: can->pa=(struct pa *)MALLOC(sizeof(struct pa));
485: can->pa[0].length=w;
486: can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
487: xstep=(double)can->width/(double)(w-1);
488: for(ix=0;ix<w;ix++){
489: #ifndef MAXSHORT
490: #define MAXSHORT ((short)0x7fff)
491: #endif
492: double t;
493:
494: pa[ix].x=(int)(ix*xstep);
495: t=(h - 1)*(ymax - RealtoDbl(tab[ix]))/dy;
496: if(t>MAXSHORT)pa[ix].y=MAXSHORT;
497: else if(t<-MAXSHORT)pa[ix].y=-MAXSHORT;
498: else pa[ix].y=(long)t;
499: }
500: plot_print(display,can);
501: copy_to_canvas(can);
502: return id;
503: }
504: /*
505: void ifplot_resize(struct canvas *can,POINT spos,POINT epos){
506: struct canvas *ncan;
507: struct canvas fakecan;
508: Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid;
509: Q sx,sy,ex,ey,cw,ch,ten,two;
510: Q s,t;
511: int new;
512: int w,h,m;
513: if(XC(spos)<XC(epos) && YC(spos)<YC(epos)){
514: if(can->precise && !can->wide){
515: fakecan=*can;
516: ncan=&fakecan;
517: } else {
518: new=search_canvas();
519: ncan=canvas[new];
520: }
521: ncan->mode=can->mode;
522: ncan->zmin=can->zmin; ncan->zmax=can->zmax;
523: ncan->nzstep=can->nzstep;
524: ncan->wname=can->wname;
525: ncan->vx=can->vx; ncan->vy=can->vy;
526: ncan->formula=can->formula;
527: w=XC(epos)-XC(spos);
528: h=YC(epos)-YC(spos);
529: m=MAX(can->width,can->height);
530: if(can->precise){
531: ncan->width=w;
532: ncan->height=h;
533: } else if(w>h){
534: ncan->width=m;
535: ncan->height=m*h/w;
536: } else {
537: ncan->width=m*w/h;
538: ncan->height=m;
539: }
540: if(can->wide){
1.2 ! noro 541: STOZ(10,ten);
! 542: STOZ(2,two);
1.1 noro 543: subq(can->qxmax,can->qxmin,&t);
544: mulq(t,ten,&dx);
545: subq(can->qymax,can->qymin,&t);
546: mulq(t,ten,&dy);
547: addq(can->qxmax,can->qxmin,&t);
548: divq(t,two,&xmid);
549: addq(can->qymax,can->qymin,&t);
550: divq(t,two,&ymid);
551: divq(dx,two,&dx2);
552: divq(dy,two,&dy2);
553: subq(xmid,dx2,&xmin);
554: addq(xmid,dx2,&xmax);
555: subq(ymid,dy2,&ymin);
556: addq(ymid,dy2,&ymax);
557: } else {
558: subq(can->qxmax,can->qxmin,&dx);
559: subq(can->qymax,can->qymin,&dy);
560: xmin=can->qxmin;
561: xmax=can->qxmax;
562: ymin=can->qymin;
563: ymax=can->qymax;
564: }
1.2 ! noro 565: STOZ(XC(spos),sx); STOZ(YC(spos),sy); STOZ(XC(epos),ex); STOZ(YC(epos),ey);
! 566: STOZ(can->width,cw); STOZ(can->height,ch);
1.1 noro 567: mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin);
568: mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);
569: mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin);
570: mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax);
571: ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
572: ncan->ymin=ToReal(ncan->qymin); ncan->ymax=ToReal(ncan->qymax);
573: if(can->precise && !can->wide){
574: current_can=can;
575: alloc_pixmap(ncan);
576: #if defined(VISUAL) || defined(__MINGW32__)
577: ncan->real_can=can;
578: #endif
579: qifplotmain(ncan);
580: copy_subimage(ncan,can,spos);
581: copy_to_canvas(can);
582: } else {
583: create_canvas(ncan);
584: if( can->precise ) qifplotmain(ncan);
585: else ifplotmain(ncan);
586: copy_to_canvas(ncan);
587: }
588: }
589: }
590: */
591:
592: void plot_resize(struct canvas *can,POINT spos,POINT epos){
593: struct canvas *ncan;
594: Q dx,dx2,xmin,xmax,xmid,s,t;
595: Z ten,two,sx,ex,cw;
596: double dy,ymin,ymax,ymid;
597: int new,w,h,m;
598:
599: if( XC(spos)<XC(epos) && YC(spos)<YC(epos) ){
600: new=search_canvas(); ncan=canvas[new];
601: ncan->mode=can->mode;
602: ncan->zmin=can->zmin; ncan->zmax=can->zmax;
603: ncan->nzstep=can->nzstep;
604: ncan->wname=can->wname;
605: ncan->vx=can->vx; ncan->vy=can->vy;
606: ncan->formula=can->formula;
607: ncan->color=can->color;
608: w=XC(epos)-XC(spos);
609: h=YC(epos)-YC(spos);
610: m=MAX(can->width,can->height);
611: if( w>h ){
612: ncan->width=m;
613: ncan->height=m * h/w;
614: } else {
615: ncan->width=m * w/h;
616: ncan->height=m;
617: }
618: if( can->wide ){
1.2 ! noro 619: STOZ(10,ten); STOZ(2,two);
1.1 noro 620: subq(can->qxmax,can->qxmin,&t); mulq(t,(Q)ten,&dx);
621: addq(can->qxmax,can->qxmin,&t); divq(t,(Q)two,&xmid);
622: divq(dx,(Q)two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax);
623: dy=(can->ymax-can->ymin)*10;
624: ymid=(can->ymax+can->ymin)/2;
625: ymin=ymid-dy/2; ymax=ymid+dy/2;
626: } else {
627: subq(can->qxmax,can->qxmin,&dx);
628: xmin=can->qxmin;
629: xmax=can->qxmax;
630: dy=can->ymax-can->ymin;
631: ymin=can->ymin;
632: ymax=can->ymax;
633: }
1.2 ! noro 634: STOZ(XC(spos),sx); STOZ(XC(epos),ex); STOZ(can->width,cw);
1.1 noro 635: mulq((Q)sx,dx,&t); divq(t,(Q)cw,&s); addq(xmin,s,&ncan->qxmin);
636: mulq((Q)ex,dx,&t); divq(t,(Q)cw,&s); addq(xmin,s,&ncan->qxmax);
637: ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
638: ncan->ymin=ymax-YC(epos)*dy/can->height;
639: ncan->ymax=ymax-YC(spos)*dy/can->height;
640: ncan->prec = can->prec;
641: create_canvas(ncan);
642:
643: switch (ncan->mode){
644: case 0://IFPLOT
645: case 1://CONPLOT
646: ifplotmain(ncan);
647: break;
648: case 2://PLOT
649: plotcalc(ncan);
650: plot_print(display,ncan);
651: break;
652: case 4://POLARPLOT
653: polarcalc(ncan);
654: plot_print(display,ncan);
655: break;
656: case 30://MEMORY_PLOT
657: break;
658: case 31://ARRAYPLOT
659: break;
660: case 33://DRAWCIRCLE
661: break;
662: case 34://DRAW_OBJ
663: break;
664: case 35://DRAW_STRING
665: break;
666: case 36://OBJ_CP
667: break;
668: case 6://IFPLOTD
669: case 7://IFPLOTQ
670: case 8://IFPLOTB
671: case 9://INEQND
672: case 10://INEQNQ
673: case 11://INEQNB
674: case 21://CONPLOTD
675: case 22://CONPLOTQ
676: case 23://CONPLOTB
677: case 24://ITVIFPLOT
678: //ifplotNG
679: ifplotmainNG(ncan);
680: break;
681: case 12://INEQNDAND
682: case 13://INEQNQAND
683: case 14://INEQNBAND
684: case 15://INEQNDOR
685: case 16://INEQNQOR
686: case 17://INEQNBOR
687: case 18://INEQNDXOR
688: case 19://INEQNQXOR
689: case 20://INEQNBXOR
690: case 25://PLOTOVERD
691: case 26://PLOTOVERQ
692: case 27://PLOTOVERB
693: //ifplotOP
694: ifplotmainNG(ncan);
695: break;
696: case 38://POLARPLOTD
697: //polarplotNG
698: polarcalcNG(ncan);
699: polar_print(display,ncan);
700: break;
701: }
702: copy_to_canvas(ncan);
703: }
704: }
705:
706: void qifplotmain(struct canvas *can)
707: {
708: int width,height;
709: char **tabe,*tabeb;
710: int i;
711:
712: width=can->width; height=can->height;
713: tabe=(char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char));
714: bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char));
715: for( i=0, tabeb=(char *)(tabe+width); i<width; i++ )
716: tabe[i]=tabeb + height*i;
717: define_cursor(can->window,runningcur);
718: set_busy(can); set_selection();
719: qcalc(tabe,can); qif_print(display,tabe,can);
720: reset_selection(); reset_busy(can);
721: define_cursor(can->window,normalcur);
722: }
723:
724: //*******************ifplotNG
725: int ifplotNG(NODE arg,int func){
726: int id,op_code;
727: unsigned int color;
728: NODE n;
729: struct canvas *can;
730: P formula;
731: LIST xrange,yrange,zrange,wsize;
732: STRING wname;
733:
734: can=canvas[id=search_canvas()];
735: formula=(P)ARG0(arg);
1.2 ! noro 736: can->color=ZTOS((Q)ARG1(arg));
1.1 noro 737: xrange=(LIST)ARG2(arg);
738: yrange=(LIST)ARG3(arg);
739: zrange=(LIST)ARG4(arg);
740: wsize=(LIST)ARG5(arg);
741: wname=(STRING)ARG6(arg);
742: can->division=0;
743: // set canvas data
744: if(xrange){
745: n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
746: can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
747: can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
748: }
749: if(yrange){
750: n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
751: can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
752: can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
753: }
754: if(zrange){
755: n=BDY(zrange); can->zmin=ToReal(BDY(n));
756: n=NEXT(n); can->zmax=ToReal(BDY(n));
1.2 ! noro 757: n=NEXT(n); can->nzstep=ZTOS((Q)BDY(n));
1.1 noro 758: }
759: if(!wsize){
760: can->width=DEFAULTWIDTH;
761: can->height=DEFAULTHEIGHT;
762: } else {
1.2 ! noro 763: can->width=ZTOS((Q)BDY(BDY(wsize)));
! 764: can->height=ZTOS((Q)BDY(NEXT(BDY(wsize))));
1.1 noro 765: }
766: if(wname) can->wname=BDY(wname);
767: else can->wname="";
768: can->formula=formula;
769: set_drawcolor(can->color);
770: can->mode=func;
771: create_canvas(can);
772: ifplotmainNG(can);
773: copy_to_canvas(can);
774: return id;
775: }
776:
777: int ifplotOP(NODE arg,int func){
778: //ineqnor[D,Q,B],ineqnand[D,Q,B],ineqnxor[D,Q,b],plotover[D,Q,B]
779: int index,op_code;
780: unsigned int orgcolor,color;
781: P formula;
782: struct canvas *can;
783: VL vl,vl0;
784: NODE n;
785:
1.2 ! noro 786: index=ZTOS((Q)ARG0(arg));
1.1 noro 787: formula=(P)ARG1(arg);
1.2 ! noro 788: color=ZTOS((Q)ARG2(arg));
1.1 noro 789: // set canvas data
790: can=canvas[index];
791: orgcolor=can->color;
792: can->color=color;
793: can->formula=formula;
794: current_can=can;
795: get_vars_recursive((Obj)formula,&vl);
796: for(vl0=vl;vl0;vl0=NEXT(vl0))
797: if(vl0->v->attr==(pointer)V_IND)
798: if(vl->v!=can->vx && vl->v!=can->vy)return -1;
799: #if !defined(VISUAL) && !defined(__MINGW32__)
800: set_drawcolor(can->color);
801: #endif
802: can->mode=func;
803: set_drawcolor(color);
804: ifplotmainNG(can);
805: set_drawcolor(orgcolor);
806: copy_to_canvas(can);
807: can->color=orgcolor;
808: #if !defined(VISUAL) && !defined(__MINGW32__)
809: set_drawcolor(can->color);
810: #endif
811: return index;
812: }
813:
814: void ifplotmainNG(struct canvas *can){
815: int width,height,i,j,ix,iy,**mask;
816: double **tabe;
817:
818: width=can->width; height=can->height;
819: tabe=(double **)ALLOCA((width+1)*sizeof(double *));
820: for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
821: define_cursor(can->window,runningcur);
822: set_busy(can); set_selection();
823: set_drawcolor(can->color);
824: switch(can->mode){
825: case 6://IFPLOTD
826: calc(tabe,can,0);
827: if_printNG(display,tabe,can,1);
828: break;
829: case 7://IFPLOTQ
830: calcq(tabe,can,0);
831: if_printNG(display,tabe,can,1);
832: break;
833: case 8://IFPLOTB
834: calcb(tabe,can,0);
835: if_printNG(display,tabe,can,0);
836: break;
837: case 9://INEQND
838: calc(tabe,can,0);
839: area_print(display,tabe,can,0);
840: break;
841: case 10://INEQNQ
842: calcq(tabe,can,0);
843: area_print(display,tabe,can,0);
844: break;
845: case 11://INEQNB
846: calcb(tabe,can,0);
847: area_print(display,tabe,can,0);
848: break;
849: case 12://INEQNFAND
850: calc(tabe,can,0);
851: area_print(display,tabe,can,2);
852: break;
853: case 13://INEQNQAND
854: calcq(tabe,can,0);
855: area_print(display,tabe,can,2);
856: break;
857: case 14://INEQNBAND
858: calcb(tabe,can,0);
859: area_print(display,tabe,can,2);
860: break;
861: case 15://INEQNDOR
862: calc(tabe,can,0);
863: area_print(display,tabe,can,3);
864: break;
865: case 16://INEQNQOR
866: calcq(tabe,can,0);
867: area_print(display,tabe,can,3);
868: break;
869: case 17://INEQNBOR
870: calcb(tabe,can,0);
871: area_print(display,tabe,can,3);
872: break;
873: case 18://INEQNDXOR
874: calc(tabe,can,0);
875: area_print(display,tabe,can,4);
876: break;
877: case 19://INEQNQXOR
878: calcq(tabe,can,0);
879: area_print(display,tabe,can,4);
880: break;
881: case 20://INEQNBXOR
882: calcb(tabe,can,0);
883: area_print(display,tabe,can,4);
884: break;
885: case 21://CONPLOTD
886: calc(tabe,can,0);
887: con_print(display,tabe,can);
888: break;
889: case 22://CONPLOTQ
890: calcq(tabe,can,0);
891: con_print(display,tabe,can);
892: break;
893: case 23://CONPLOTB
894: calcb(tabe,can,0);
895: con_print(display,tabe,can);
896: break;
897: #if defined(INTERVAL)
898: case 24://ITVIFPLOT:
899: itvcalc(tabe,can,1);
900: if_printNG(display,tabe,can,1);
901: break;
902: #endif
903: case 25://PLOTOVERD
904: calc(tabe,can,0);
905: over_print(display,tabe,can,0);
906: break;
907: case 26://PLOTOVERQ:
908: calcq(tabe,can,0);
909: over_print(display,tabe,can,0);
910: break;
911: case 27://PLOTOVERB:
912: calcb(tabe,can,0);
913: over_print(display,tabe,can,0);
914: break;
915: }
916: set_drawcolor(can->color);
917: reset_selection(); reset_busy(can);
918: define_cursor(can->window,normalcur);
919: }
920:
921: #if !defined(VISUAL) && !defined(__MINGW32__)
922: int objcp(NODE arg){
923: int idsrc, idtrg, op_code;
924: struct canvas *cansrc, *cantrg;
925:
1.2 ! noro 926: idsrc=ZTOS((Q)ARG0(arg));
! 927: idtrg=ZTOS((Q)ARG1(arg));
! 928: op_code=ZTOS((Q)ARG2(arg));
1.1 noro 929: cansrc=canvas[idsrc];
930: cantrg=canvas[idtrg];
931: obj_op(cansrc, cantrg, op_code);
932: return idsrc;
933: }
934:
935: void obj_op(struct canvas *cansrc, struct canvas *cantrg, int op){
936: XImage *imgsrc, *imgtrg;
937: int width, height, i, j;
938: unsigned long src, trg, black, white;
939:
940: width=cansrc->width; height=cansrc->height;
941: imgsrc=XGetImage(display, cansrc->pix, 0, 0, width, height, -1, ZPixmap);
942: imgtrg=XGetImage(display, cantrg->pix, 0, 0, width, height, -1, ZPixmap);
943: black=GetColor(display, "black");
944: white=GetColor(display, "white");
945: flush();
946: define_cursor(cantrg->window,runningcur);
947: set_busy(cantrg); set_selection();
948: cantrg->precise=cansrc->precise;
949: cantrg->noaxis=cansrc->noaxis;
950: cantrg->noaxisb=cansrc->noaxisb;
951: cantrg->vx=cansrc->vx;
952: cantrg->vy=cansrc->vy;
953: cantrg->formula=cansrc->formula;
954: cantrg->width=cansrc->width;
955: cantrg->height=cansrc->height;
956: cantrg->xmin=cansrc->xmin;
957: cantrg->xmax=cansrc->xmax;
958: cantrg->ymin=cansrc->ymin;
959: cantrg->ymax=cansrc->ymax;
960: cantrg->zmin=cansrc->zmin;
961: cantrg->zmax=cansrc->zmax;
962: cantrg->nzstep=cansrc->nzstep;
963: cantrg->qxmin=cansrc->qxmin;
964: cantrg->qxmax=cansrc->qxmax;
965: cantrg->qymin=cansrc->qymin;
966: cantrg->qymax=cansrc->qymax;
967: cantrg->pa=cansrc->pa;
968: switch(op){
969: case 1:/* and case */
970: for(i=0;i<width;i++)for(j=0;j<height;j++){
971: src=XGetPixel(imgsrc,i,j);
972: trg=XGetPixel(imgtrg,i,j);
973: if( (src == black) || (trg == black) )
974: XPutPixel(imgtrg,i,j,black);
975: else if( (src == white) || (trg == white) )
976: XPutPixel(imgtrg,i,j,white);
977: else XPutPixel(imgtrg,i,j,(src & trg));
978: }
979: break;
980: case 3:/* copy case */
981: imgtrg->data=imgsrc->data;
982: break;
983: case 6:/* xor case */
984: for(i=0;i<width;i++)for(j=0;j<height;j++){
985: src=XGetPixel(imgsrc,i,j);
986: trg=XGetPixel(imgtrg,i,j);
987: if( (src == black) || (trg == black) )
988: XPutPixel(imgtrg,i,j,black);
989: else if( (src == white) && (trg == white) )
990: XPutPixel(imgtrg,i,j,trg|src);
991: else if( (src != white) && (trg != white) )
992: XPutPixel(imgtrg,i,j,white);
993: else if( src == white )
994: XPutPixel(imgtrg,i,j,src);
995: }
996: break;
997: case 7:/* or case */
998: for(i=0;i<width;i++)for(j=0;j<height;j++){
999: src=XGetPixel(imgsrc,i,j);
1000: trg=XGetPixel(imgtrg,i,j);
1001: if( (src == black) || (trg == black) )
1002: XPutPixel(imgtrg,i,j,black);
1003: else if(src == white)
1004: XPutPixel(imgtrg,i,j,trg);
1005: else if(trg == white)
1006: XPutPixel(imgtrg,i,j,src);
1007: }
1008: break;
1009: default:
1010: break;
1011: }
1012: XPutImage(display, cantrg->pix, drawGC, imgtrg, 0, 0, 0, 0, width, height);
1013: reset_selection(); reset_busy(cantrg);
1014: define_cursor(cantrg->window,normalcur);
1015: copy_to_canvas(cantrg);
1016: count_and_flush();
1017: flush();
1018: }
1019: #endif
1020:
1021: int polarplotNG(NODE arg){
1022: int i,id,width,height;
1023: NODE n;
1024: struct canvas *can;
1025: LIST range,geom;
1026: STRING wname;
1027: V v;
1028:
1029: id=search_canvas();
1030: can=canvas[id];
1031: can->mode=modeNO(POLARPLOTD);
1032: can->formula=(P)ARG0(arg);
1.2 ! noro 1033: can->color=ZTOS((Q)ARG1(arg));
1.1 noro 1034: range=(LIST)ARG2(arg);
1035: geom=(LIST)ARG3(arg);
1036: wname=(STRING)ARG4(arg);
1037:
1038: if(range){
1039: n=NEXT(BDY(range));
1040: can->zmin=ToReal(BDY(n));
1041: n=NEXT(n);can->zmax=ToReal(BDY(n));
1042: n=NEXT(n);
1043: can->vx=VR((P)BDY(BDY(range)));
1.2 ! noro 1044: can->nzstep=n?ZTOS((Q)BDY(n)):DEFAULTPOLARSTEP;
1.1 noro 1045: }
1046: if(geom){
1.2 ! noro 1047: can->width=width=ZTOS((Q)BDY(BDY(geom)));
! 1048: can->height=height=ZTOS((Q)BDY(NEXT(BDY(geom))));
1.1 noro 1049: }
1050: if(wname)can->wname=BDY(wname);
1051: else can->wname="";
1052: polarcalcNG(can);
1053: create_canvas(can);
1054: set_drawcolor(can->color);
1055: polar_print(display,can);
1056: reset_selection();
1057: reset_busy(can);
1058: define_cursor(can->window,normalcur);
1059: return id;
1060: }
1061:
1062: void MSGdraw(char *str){
1063: int id,x,y;
1064: struct canvas *can;
1065:
1066: id=search_canvas();
1067: can=canvas[id];
1068: can->mode=modeNO(INTERACTIVE);
1069: can->width=300;
1070: can->height=300;
1071: can->wname="MSG";
1072: x=100;
1073: y=100;
1074: create_canvas(can);
1075: draw_character_string(display,can,x,y,str,0xff0000);
1076: }
1077:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to if.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2018 / plot