Actual source code: drawimage.c
petsc-3.11.4 2019-09-28
1: #include <../src/sys/classes/draw/impls/image/drawimage.h>
2: #include <petsc/private/drawimpl.h>
4: #if defined(PETSC_USE_DEBUG)
5: #define PetscDrawValidColor(color) \
6: do { if (PetscUnlikely((color)<0||(color)>=256)) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Color value %D out of range [0..255]",(PetscInt)(color)); } while (0)
7: #else
8: #define PetscDrawValidColor(color) do {} while (0)
9: #endif
11: #define XTRANS(draw,img,x) ((int)(((img)->w-1)*((draw)->port_xl + ((((x) - (draw)->coor_xl)*((draw)->port_xr - (draw)->port_xl))/((draw)->coor_xr - (draw)->coor_xl)))))
12: #define YTRANS(draw,img,y) (((img)->h-1) - (int)(((img)->h-1)*((draw)->port_yl + ((((y) - (draw)->coor_yl)*((draw)->port_yr - (draw)->port_yl))/((draw)->coor_yr - (draw)->coor_yl)))))
14: #define ITRANS(draw,img,i) ((draw)->coor_xl + (((PetscReal)(i))*((draw)->coor_xr - (draw)->coor_xl)/((img)->w-1) - (draw)->port_xl)/((draw)->port_xr - (draw)->port_xl))
15: #define JTRANS(draw,img,j) ((draw)->coor_yl + (((PetscReal)(j))/((img)->h-1) + (draw)->port_yl - 1)*((draw)->coor_yr - (draw)->coor_yl)/((draw)->port_yl - (draw)->port_yr))
18: static PetscErrorCode PetscDrawSetViewport_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr)
19: {
20: PetscImage img = (PetscImage)draw->data;
22: {
23: int xmax = img->w - 1, ymax = img->h - 1;
24: int xa = (int)(xl*xmax), ya = ymax - (int)(yr*ymax);
25: int xb = (int)(xr*xmax), yb = ymax - (int)(yl*ymax);
26: PetscImageSetClip(img,xa,ya,xb+1-xa,yb+1-ya);
27: }
28: return(0);
29: }
31: /*
32: static PetscErrorCode PetscDrawSetCoordinates_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr)
33: {
35: return(0);
36: }*/
37: #define PetscDrawSetCoordinates_Image NULL
39: static PetscErrorCode PetscDrawCoordinateToPixel_Image(PetscDraw draw,PetscReal x,PetscReal y,int *i,int *j)
40: {
41: PetscImage img = (PetscImage)draw->data;
43: if (i) *i = XTRANS(draw,img,x);
44: if (j) *j = YTRANS(draw,img,y);
45: return(0);
46: }
48: static PetscErrorCode PetscDrawPixelToCoordinate_Image(PetscDraw draw,int i,int j,PetscReal *x,PetscReal *y)
49: {
50: PetscImage img = (PetscImage)draw->data;
52: if (x) *x = ITRANS(draw,img,i);
53: if (y) *y = JTRANS(draw,img,j);
54: return(0);
55: }
57: /*
58: static PetscErrorCode PetscDrawPointSetSize_Image(PetscDraw draw,PetscReal width)
59: {
61: return(0);
62: }*/
63: #define PetscDrawPointSetSize_Image NULL
65: static PetscErrorCode PetscDrawPoint_Image(PetscDraw draw,PetscReal x,PetscReal y,int c)
66: {
67: PetscImage img = (PetscImage)draw->data;
69: PetscDrawValidColor(c);
70: {
71: int j, xx = XTRANS(draw,img,x);
72: int i, yy = YTRANS(draw,img,y);
73: for (i=-1; i<=1; i++)
74: for (j=-1; j<=1; j++)
75: PetscImageDrawPixel(img,xx+j,yy+i,c);
76: }
77: return(0);
78: }
80: static PetscErrorCode PetscDrawPointPixel_Image(PetscDraw draw,int x,int y,int c)
81: {
82: PetscImage img = (PetscImage)draw->data;
84: PetscDrawValidColor(c);
85: {
86: PetscImageDrawPixel(img,x,y,c);
87: }
88: return(0);
89: }
91: /*
92: static PetscErrorCode PetscDrawLineSetWidth_Image(PetscDraw draw,PetscReal width)
93: {
95: return(0);
96: }*/
97: #define PetscDrawLineSetWidth_Image NULL
99: static PetscErrorCode PetscDrawLineGetWidth_Image(PetscDraw draw,PetscReal *width)
100: {
101: PetscImage img = (PetscImage)draw->data;
103: {
104: int lw = 1;
105: *width = lw*(draw->coor_xr - draw->coor_xl)/(img->w*(draw->port_xr - draw->port_xl));
106: }
107: return(0);
108: }
110: static PetscErrorCode PetscDrawLine_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c)
111: {
112: PetscImage img = (PetscImage)draw->data;
114: {
115: int x_1 = XTRANS(draw,img,xl), x_2 = XTRANS(draw,img,xr);
116: int y_1 = YTRANS(draw,img,yl), y_2 = YTRANS(draw,img,yr);
117: PetscImageDrawLine(img,x_1,y_1,x_2,y_2,c);
118: }
119: return(0);
120: }
122: static PetscErrorCode PetscDrawArrow_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c)
123: {
124: PetscImage img = (PetscImage)draw->data;
126: PetscDrawValidColor(c);
127: {
128: int x_1 = XTRANS(draw,img,xl), x_2 = XTRANS(draw,img,xr);
129: int y_1 = YTRANS(draw,img,yl), y_2 = YTRANS(draw,img,yr);
130: if (x_1 == x_2 && y_1 == y_2) return(0);
131: PetscImageDrawLine(img,x_1,y_1,x_2,y_2,c);
132: if (x_1 == x_2 && PetscAbs(y_1 - y_2) > 7) {
133: if (y_2 > y_1) {
134: PetscImageDrawLine(img,x_2,y_2,x_2-3,y_2-3,c);
135: PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2-3,c);
136: } else {
137: PetscImageDrawLine(img,x_2,y_2,x_2-3,y_2+3,c);
138: PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2+3,c);
139: }
140: }
141: if (y_1 == y_2 && PetscAbs(x_1 - x_2) > 7) {
142: if (x_2 > x_1) {
143: PetscImageDrawLine(img,x_2-3,y_2-3,x_2,y_2,c);
144: PetscImageDrawLine(img,x_2-3,y_2+3,x_2,y_2,c);
145: } else {
146: PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2-3,c);
147: PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2+3,c);
148: }
149: }
150: }
151: return(0);
152: }
154: static PetscErrorCode PetscDrawRectangle_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c1,int c2,int c3,int c4)
155: {
156: PetscImage img = (PetscImage)draw->data;
158: PetscDrawValidColor(c1);
159: PetscDrawValidColor(c2);
160: PetscDrawValidColor(c3);
161: PetscDrawValidColor(c4);
162: {
163: int x = XTRANS(draw,img,xl), w = XTRANS(draw,img,xr) + 1 - x;
164: int y = YTRANS(draw,img,yr), h = YTRANS(draw,img,yl) + 1 - y;
165: int c = (c1 + c2 + c3 + c4)/4;
166: PetscImageDrawRectangle(img,x,y,w,h,c);
167: }
168: return(0);
169: }
171: static PetscErrorCode PetscDrawEllipse_Image(PetscDraw draw,PetscReal x,PetscReal y,PetscReal a,PetscReal b,int c)
172: {
173: PetscImage img = (PetscImage)draw->data;
175: PetscDrawValidColor(c);
176: a = PetscAbsReal(a);
177: b = PetscAbsReal(b);
178: {
179: int xc = XTRANS(draw,img,x), w = XTRANS(draw,img,x + a/2) + 0 - xc;
180: int yc = YTRANS(draw,img,y), h = YTRANS(draw,img,y - b/2) + 0 - yc;
181: if (PetscAbsReal(a-b) <= 0) w = h = PetscMin(w,h); /* workaround truncation errors */
182: PetscImageDrawEllipse(img,xc,yc,w,h,c);
183: }
184: return(0);
185: }
187: static PetscErrorCode PetscDrawTriangle_Image(PetscDraw draw,PetscReal X_1,PetscReal Y_1,PetscReal X_2,PetscReal Y_2,PetscReal X_3,PetscReal Y_3,int c1,int c2,int c3)
188: {
189: PetscImage img = (PetscImage)draw->data;
191: PetscDrawValidColor(c1);
192: PetscDrawValidColor(c2);
193: PetscDrawValidColor(c3);
194: {
195: int x_1 = XTRANS(draw,img,X_1), x_2 = XTRANS(draw,img,X_2), x_3 = XTRANS(draw,img,X_3);
196: int y_1 = YTRANS(draw,img,Y_1), y_2 = YTRANS(draw,img,Y_2), y_3 = YTRANS(draw,img,Y_3);
197: PetscImageDrawTriangle(img,x_1,y_1,c1,x_2,y_2,c2,x_3,y_3,c3);
198: }
199: return(0);
200: }
202: /*
203: static PetscErrorCode PetscDrawStringSetSize_Image(PetscDraw draw,PetscReal w,PetscReal h)
204: {
206: return(0);
207: }*/
208: #define PetscDrawStringSetSize_Image NULL
210: static PetscErrorCode PetscDrawStringGetSize_Image(PetscDraw draw,PetscReal *w,PetscReal *h)
211: {
212: PetscImage img = (PetscImage)draw->data;
214: {
215: int tw = PetscImageFontWidth;
216: int th = PetscImageFontHeight;
217: if (w) *w = tw*(draw->coor_xr - draw->coor_xl)/(img->w*(draw->port_xr - draw->port_xl));
218: if (h) *h = th*(draw->coor_yr - draw->coor_yl)/(img->h*(draw->port_yr - draw->port_yl));
219: }
220: return(0);
221: }
223: static PetscErrorCode PetscDrawString_Image(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])
224: {
225: PetscImage img = (PetscImage)draw->data;
226: PetscToken token;
227: char *subtext;
230: PetscDrawValidColor(c);
231: {
232: int xx = XTRANS(draw,img,x);
233: int yy = YTRANS(draw,img,y);
234: PetscTokenCreate(text,'\n',&token);
235: PetscTokenFind(token,&subtext);
236: while (subtext) {
237: PetscImageDrawText(img,xx,yy,c,subtext);
238: yy += PetscImageFontHeight;
239: PetscTokenFind(token,&subtext);
240: }
241: PetscTokenDestroy(&token);
242: }
243: return(0);
244: }
246: static PetscErrorCode PetscDrawStringVertical_Image(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])
247: {
248: PetscImage img = (PetscImage)draw->data;
250: PetscDrawValidColor(c);
251: {
252: char chr[2] = {0, 0};
253: int xx = XTRANS(draw,img,x);
254: int yy = YTRANS(draw,img,y);
255: int offset = PetscImageFontHeight;
256: while ((chr[0] = *text++)) {
257: PetscImageDrawText(img,xx,yy+offset,c,chr);
258: yy += PetscImageFontHeight;
259: }
260: }
261: return(0);
262: }
264: /*
265: static PetscErrorCode PetscDrawStringBoxed_Image(PetscDraw draw,PetscReal sxl,PetscReal syl,int sc,int bc,const char text[],PetscReal *w,PetscReal *h)
266: {
268: if (w) *w = 0;
269: if (h) *h = 0;
270: return(0);
271: */
272: #define PetscDrawStringBoxed_Image NULL
274: /*
275: static PetscErrorCode PetscDrawFlush_Image(PetscDraw draw)
276: {
278: return(0);
279: }*/
280: #define PetscDrawFlush_Image NULL
282: static PetscErrorCode PetscDrawClear_Image(PetscDraw draw)
283: {
284: PetscImage img = (PetscImage)draw->data;
286: {
287: PetscImageClear(img);
288: }
289: return(0);
290: }
292: /*
293: static PetscErrorCode PetscDrawSetDoubleBuffer_Image(PetscDraw draw)
294: {
296: return(0);
297: }*/
298: #define PetscDrawSetDoubleBuffer_Image NULL
300: static PetscErrorCode PetscDrawGetPopup_Image(PetscDraw draw,PetscDraw *popup)
301: {
302: PetscBool flg = PETSC_FALSE;
306: PetscOptionsGetBool(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_popup",&flg,NULL);
307: if (!flg) {*popup = NULL; return(0);}
308: PetscDrawCreate(PetscObjectComm((PetscObject)draw),NULL,NULL,0,0,220,220,popup);
309: PetscDrawSetType(*popup,PETSC_DRAW_IMAGE);
310: PetscObjectSetOptionsPrefix((PetscObject)*popup,"popup_");
311: PetscObjectAppendOptionsPrefix((PetscObject)*popup,((PetscObject)draw)->prefix);
312: draw->popup = *popup;
313: return(0);
314: }
316: /*
317: static PetscErrorCode PetscDrawSetTitle_Image(PetscDraw draw,const char title[])
318: {
320: return(0);
321: }*/
322: #define PetscDrawSetTitle_Image NULL
324: /*
325: static PetscErrorCode PetscDrawCheckResizedWindow_Image(PetscDraw draw)
326: {
328: return(0);
329: }*/
330: #define PetscDrawCheckResizedWindow_Image NULL
332: static PetscErrorCode PetscDrawResizeWindow_Image(PetscDraw draw,int w,int h)
333: {
334: PetscImage img = (PetscImage)draw->data;
338: if (w == img->w && h == img->h) return(0);
339: PetscFree(img->buffer);
341: img->w = w; img->h = h;
342: PetscCalloc1((size_t)(img->w*img->h),&img->buffer);
343: PetscDrawSetViewport_Image(draw,draw->port_xl,draw->port_yl,draw->port_xr,draw->port_yr);
344: return(0);
345: }
347: static PetscErrorCode PetscDrawDestroy_Image(PetscDraw draw)
348: {
349: PetscImage img = (PetscImage)draw->data;
353: PetscDrawDestroy(&draw->popup);
354: PetscFree(img->buffer);
355: PetscFree(draw->data);
356: return(0);
357: }
359: /*
360: static PetscErrorCode PetscDrawView_Image(PetscDraw draw,PetscViewer viewer)
361: {
363: return(0);
364: }*/
365: #define PetscDrawView_Image NULL
367: /*
368: static PetscErrorCode PetscDrawGetMouseButton_Image(PetscDraw draw,PetscDrawButton *button,PetscReal *x_user,PetscReal *y_user,PetscReal *x_phys,PetscReal *y_phys)
369: {
371: *button = PETSC_BUTTON_NONE;
372: if (x_user) *x_user = 0;
373: if (y_user) *y_user = 0;
374: if (x_phys) *x_phys = 0;
375: if (y_phys) *y_phys = 0;
376: return(0);
377: }*/
378: #define PetscDrawGetMouseButton_Image NULL
380: /*
381: static PetscErrorCode PetscDrawPause_Image(PetscDraw draw)
382: {
384: return(0);
385: }*/
386: #define PetscDrawPause_Image NULL
388: /*
389: static PetscErrorCode PetscDrawBeginPage_Image(PetscDraw draw)
390: {
392: return(0);
393: }*/
394: #define PetscDrawBeginPage_Image NULL
396: /*
397: static PetscErrorCode PetscDrawEndPage_Image(PetscDraw draw)
398: {
400: return(0);
401: }*/
402: #define PetscDrawEndPage_Image NULL
404: static PetscErrorCode PetscDrawGetSingleton_Image(PetscDraw draw,PetscDraw *sdraw)
405: {
406: PetscImage pimg = (PetscImage)draw->data;
407: PetscImage simg;
411: PetscDrawCreate(PETSC_COMM_SELF,NULL,NULL,0,0,draw->w,draw->h,sdraw);
412: PetscDrawSetType(*sdraw,PETSC_DRAW_IMAGE);
413: (*sdraw)->ops->resizewindow = NULL;
414: simg = (PetscImage)(*sdraw)->data;
415: PetscMemcpy(simg->buffer,pimg->buffer,(size_t)(pimg->w*pimg->h));
416: return(0);
417: }
419: static PetscErrorCode PetscDrawRestoreSingleton_Image(PetscDraw draw,PetscDraw *sdraw)
420: {
421: PetscImage pimg = (PetscImage)draw->data;
422: PetscImage simg = (PetscImage)(*sdraw)->data;
426: PetscMemcpy(pimg->buffer,simg->buffer,(size_t)(pimg->w*pimg->h));
427: PetscDrawDestroy(sdraw);
428: return(0);
429: }
431: /*
432: static PetscErrorCode PetscDrawSave_Image(PetscDraw draw)
433: {
435: return(0);
436: }*/
437: #define PetscDrawSave_Image NULL
439: static PetscErrorCode PetscDrawGetImage_Image(PetscDraw draw,unsigned char palette[256][3],unsigned int *w,unsigned int *h,unsigned char *pixels[])
440: {
441: PetscImage img = (PetscImage)draw->data;
442: unsigned char *buffer = NULL;
443: PetscMPIInt rank,size;
447: if (w) *w = (unsigned int)img->w;
448: if (h) *h = (unsigned int)img->h;
449: if (pixels) *pixels = NULL;
450: MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
451: if (!rank) {
452: PetscMemcpy(palette,img->palette,sizeof(img->palette));
453: PetscMalloc1((size_t)(img->w*img->h),&buffer);
454: if (pixels) *pixels = buffer;
455: }
456: MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
457: if (size == 1) {
458: PetscMemcpy(buffer,img->buffer,(size_t)(img->w*img->h));
459: } else {
460: MPI_Reduce(img->buffer,buffer,img->w*img->h,MPI_UNSIGNED_CHAR,MPI_MAX,0,PetscObjectComm((PetscObject)draw));
461: }
462: return(0);
463: }
465: static struct _PetscDrawOps DvOps = {
466: PetscDrawSetDoubleBuffer_Image,
467: PetscDrawFlush_Image,
468: PetscDrawLine_Image,
469: PetscDrawLineSetWidth_Image,
470: PetscDrawLineGetWidth_Image,
471: PetscDrawPoint_Image,
472: PetscDrawPointSetSize_Image,
473: PetscDrawString_Image,
474: PetscDrawStringVertical_Image,
475: PetscDrawStringSetSize_Image,
476: PetscDrawStringGetSize_Image,
477: PetscDrawSetViewport_Image,
478: PetscDrawClear_Image,
479: PetscDrawRectangle_Image,
480: PetscDrawTriangle_Image,
481: PetscDrawEllipse_Image,
482: PetscDrawGetMouseButton_Image,
483: PetscDrawPause_Image,
484: PetscDrawBeginPage_Image,
485: PetscDrawEndPage_Image,
486: PetscDrawGetPopup_Image,
487: PetscDrawSetTitle_Image,
488: PetscDrawCheckResizedWindow_Image,
489: PetscDrawResizeWindow_Image,
490: PetscDrawDestroy_Image,
491: PetscDrawView_Image,
492: PetscDrawGetSingleton_Image,
493: PetscDrawRestoreSingleton_Image,
494: PetscDrawSave_Image,
495: PetscDrawGetImage_Image,
496: PetscDrawSetCoordinates_Image,
497: PetscDrawArrow_Image,
498: PetscDrawCoordinateToPixel_Image,
499: PetscDrawPixelToCoordinate_Image,
500: PetscDrawPointPixel_Image,
501: PetscDrawStringBoxed_Image
502: };
504: static const unsigned char BasicColors[PETSC_DRAW_BASIC_COLORS][3] = {
505: { 255, 255, 255 }, /* white */
506: { 0, 0, 0 }, /* black */
507: { 255, 0, 0 }, /* red */
508: { 0, 255, 0 }, /* green */
509: { 0, 255, 255 }, /* cyan */
510: { 0, 0, 255 }, /* blue */
511: { 255, 0, 255 }, /* magenta */
512: { 127, 255, 212 }, /* aquamarine */
513: { 34, 139, 34 }, /* forestgreen */
514: { 255, 165, 0 }, /* orange */
515: { 238, 130, 238 }, /* violet */
516: { 165, 42, 42 }, /* brown */
517: { 255, 192, 203 }, /* pink */
518: { 255, 127, 80 }, /* coral */
519: { 190, 190, 190 }, /* gray */
520: { 255, 255, 0 }, /* yellow */
521: { 255, 215, 0 }, /* gold */
522: { 255, 182, 193 }, /* lightpink */
523: { 72, 209, 204 }, /* mediumturquoise */
524: { 240, 230, 140 }, /* khaki */
525: { 105, 105, 105 }, /* dimgray */
526: { 54, 205, 50 }, /* yellowgreen */
527: { 135, 206, 235 }, /* skyblue */
528: { 0, 100, 0 }, /* darkgreen */
529: { 0, 0, 128 }, /* navyblue */
530: { 244, 164, 96 }, /* sandybrown */
531: { 95, 158, 160 }, /* cadetblue */
532: { 176, 224, 230 }, /* powderblue */
533: { 255, 20, 147 }, /* deeppink */
534: { 216, 191, 216 }, /* thistle */
535: { 50, 205, 50 }, /* limegreen */
536: { 255, 240, 245 }, /* lavenderblush */
537: { 221, 160, 221 }, /* plum */
538: };
541: /*MC
542: PETSC_DRAW_IMAGE - PETSc graphics device that uses a raster buffer
544: Options Database Keys:
545: . -draw_size w,h - size of image in pixels
547: Level: beginner
549: .seealso: PetscDrawOpenImage(), PetscDrawSetFromOptions()
550: M*/
551: PETSC_EXTERN PetscErrorCode PetscDrawCreate_Image(PetscDraw);
553: PETSC_EXTERN PetscErrorCode PetscDrawCreate_Image(PetscDraw draw)
554: {
555: PetscImage img;
556: int w = draw->w, h = draw->h;
557: PetscInt size[2], nsize = 2;
558: PetscBool set;
562: draw->pause = 0;
563: draw->coor_xl = 0; draw->coor_xr = 1;
564: draw->coor_yl = 0; draw->coor_yr = 1;
565: draw->port_xl = 0; draw->port_xr = 1;
566: draw->port_yl = 0; draw->port_yr = 1;
568: size[0] = w; if (size[0] < 1) size[0] = 300;
569: size[1] = h; if (size[1] < 1) size[1] = size[0];
570: PetscOptionsGetIntArray(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_size",size,&nsize,&set);
571: if (set && nsize == 1) size[1] = size[0];
572: if (size[0] < 1) size[0] = 300;
573: if (size[1] < 1) size[1] = size[0];
574: draw->w = w = size[0]; draw->x = 0;
575: draw->h = h = size[1]; draw->x = 0;
577: PetscNewLog(draw,&img);
578: PetscMemcpy(draw->ops,&DvOps,sizeof(DvOps));
579: draw->data = (void*)img;
581: img->w = w; img->h = h;
582: PetscCalloc1((size_t)(img->w*img->h),&img->buffer);
583: PetscImageSetClip(img,0,0,img->w,img->h);
584: {
585: int i,k,ncolors = 256-PETSC_DRAW_BASIC_COLORS;
586: unsigned char R[256-PETSC_DRAW_BASIC_COLORS];
587: unsigned char G[256-PETSC_DRAW_BASIC_COLORS];
588: unsigned char B[256-PETSC_DRAW_BASIC_COLORS];
589: PetscDrawUtilitySetCmap(NULL,ncolors,R,G,B);
590: for (k=0; k<PETSC_DRAW_BASIC_COLORS; k++) {
591: img->palette[k][0] = BasicColors[k][0];
592: img->palette[k][1] = BasicColors[k][1];
593: img->palette[k][2] = BasicColors[k][2];
594: }
595: for (i=0; i<ncolors; i++, k++) {
596: img->palette[k][0] = R[i];
597: img->palette[k][1] = G[i];
598: img->palette[k][2] = B[i];
599: }
600: }
602: if (!draw->savefilename) {PetscDrawSetSave(draw,draw->title);}
603: return(0);
604: }
606: /*@C
607: PetscDrawOpenImage - Opens an image for use with the PetscDraw routines.
609: Collective on MPI_Comm
611: Input Parameters:
612: + comm - the communicator that will share image
613: - filename - optional name of the file
614: - w, h - the image width and height in pixels
616: Output Parameters:
617: . draw - the drawing context.
619: Level: beginner
621: .seealso: PetscDrawSetSave(), PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
622: @*/
623: PetscErrorCode PetscDrawOpenImage(MPI_Comm comm,const char filename[],int w,int h,PetscDraw *draw)
624: {
628: PetscDrawCreate(comm,NULL,NULL,0,0,w,h,draw);
629: PetscDrawSetType(*draw,PETSC_DRAW_IMAGE);
630: PetscDrawSetSave(*draw,filename);
631: return(0);
632: }