Date: 2016-07-24T16:46:36+00:00

Actual source code: drawimage.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      1: #include <../src/sys/classes/draw/impls/image/drawimage.h>   /*I  "petscdraw.h" I*/
      2: #include <petsc/private/drawimpl.h>                          /*I  "petscdraw.h" I*/

      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))

     20: static PetscErrorCode PetscDrawSetViewport_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr)
     21: {
     22:   PetscImage img = (PetscImage)draw->data;
     24:   {
     25:     int xmax = img->w - 1,   ymax = img->h - 1;
     26:     int xa = (int)(xl*xmax), ya = ymax - (int)(yr*ymax);
     27:     int xb = (int)(xr*xmax), yb = ymax - (int)(yl*ymax);
     28:     PetscImageSetClip(img,xa,ya,xb+1-xa,yb+1-ya);
     29:   }
     30:   return(0);
     31: }

     33: /*
     36: static PetscErrorCode PetscDrawSetCoordinates_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr)
     37: {
     39:   return(0);
     40: }*/
     41: #define PetscDrawSetCoordinates_Image NULL

     45: static PetscErrorCode PetscDrawCoordinateToPixel_Image(PetscDraw draw,PetscReal x,PetscReal y,int *i,int *j)
     46: {
     47:   PetscImage img = (PetscImage)draw->data;
     49:   if (i) *i = XTRANS(draw,img,x);
     50:   if (j) *j = YTRANS(draw,img,y);
     51:   return(0);
     52: }

     56: static PetscErrorCode PetscDrawPixelToCoordinate_Image(PetscDraw draw,int i,int j,PetscReal *x,PetscReal *y)
     57: {
     58:   PetscImage img = (PetscImage)draw->data;
     60:   if (x) *x = ITRANS(draw,img,i);
     61:   if (y) *y = JTRANS(draw,img,j);
     62:   return(0);
     63: }

     65: /*
     68: static PetscErrorCode PetscDrawPointSetSize_Image(PetscDraw draw,PetscReal width)
     69: {
     71:   return(0);
     72: }*/
     73: #define PetscDrawPointSetSize_Image NULL

     77: static PetscErrorCode PetscDrawPoint_Image(PetscDraw draw,PetscReal x,PetscReal y,int c)
     78: {
     79:   PetscImage img = (PetscImage)draw->data;
     81:   PetscDrawValidColor(c);
     82:   {
     83:     int j, xx = XTRANS(draw,img,x);
     84:     int i, yy = YTRANS(draw,img,y);
     85:     for (i=-1; i<=1; i++)
     86:       for (j=-1; j<=1; j++)
     87:         PetscImageDrawPixel(img,xx+j,yy+i,c);
     88:   }
     89:   return(0);
     90: }

     94: static PetscErrorCode PetscDrawPointPixel_Image(PetscDraw draw,int x,int y,int c)
     95: {
     96:   PetscImage img = (PetscImage)draw->data;
     98:   PetscDrawValidColor(c);
     99:   {
    100:     PetscImageDrawPixel(img,x,y,c);
    101:   }
    102:   return(0);
    103: }

    105: /*
    108: static PetscErrorCode PetscDrawLineSetWidth_Image(PetscDraw draw,PetscReal width)
    109: {
    111:   return(0);
    112: }*/
    113: #define PetscDrawLineSetWidth_Image NULL

    117: static PetscErrorCode PetscDrawLineGetWidth_Image(PetscDraw draw,PetscReal *width)
    118: {
    119:   PetscImage img = (PetscImage)draw->data;
    121:   {
    122:     int lw = 1;
    123:     *width = lw*(draw->coor_xr - draw->coor_xl)/(img->w*(draw->port_xr - draw->port_xl));
    124:   }
    125:   return(0);
    126: }

    130: static PetscErrorCode PetscDrawLine_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c)
    131: {
    132:   PetscImage img = (PetscImage)draw->data;
    134:   {
    135:     int x_1 = XTRANS(draw,img,xl), x_2 = XTRANS(draw,img,xr);
    136:     int y_1 = YTRANS(draw,img,yl), y_2 = YTRANS(draw,img,yr);
    137:     PetscImageDrawLine(img,x_1,y_1,x_2,y_2,c);
    138:   }
    139:   return(0);
    140: }

    144: static PetscErrorCode PetscDrawArrow_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c)
    145: {
    146:   PetscImage img = (PetscImage)draw->data;
    148:   PetscDrawValidColor(c);
    149:   {
    150:     int x_1 = XTRANS(draw,img,xl), x_2 = XTRANS(draw,img,xr);
    151:     int y_1 = YTRANS(draw,img,yl), y_2 = YTRANS(draw,img,yr);
    152:     if (x_1 == x_2 && y_1 == y_2) return(0);
    153:     PetscImageDrawLine(img,x_1,y_1,x_2,y_2,c);
    154:     if (x_1 == x_2 && PetscAbs(y_1 - y_2) > 7) {
    155:       if (y_2 > y_1) {
    156:         PetscImageDrawLine(img,x_2,y_2,x_2-3,y_2-3,c);
    157:         PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2-3,c);
    158:       } else {
    159:         PetscImageDrawLine(img,x_2,y_2,x_2-3,y_2+3,c);
    160:         PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2+3,c);
    161:       }
    162:     }
    163:     if (y_1 == y_2 && PetscAbs(x_1 - x_2) > 7) {
    164:       if (x_2 > x_1) {
    165:         PetscImageDrawLine(img,x_2-3,y_2-3,x_2,y_2,c);
    166:         PetscImageDrawLine(img,x_2-3,y_2+3,x_2,y_2,c);
    167:       } else {
    168:         PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2-3,c);
    169:         PetscImageDrawLine(img,x_2,y_2,x_2+3,y_2+3,c);
    170:       }
    171:     }
    172:    }
    173:   return(0);
    174: }

    178: static PetscErrorCode PetscDrawRectangle_Image(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c1,int c2,int c3,int c4)
    179: {
    180:   PetscImage img = (PetscImage)draw->data;
    182:   PetscDrawValidColor(c1);
    183:   PetscDrawValidColor(c2);
    184:   PetscDrawValidColor(c3);
    185:   PetscDrawValidColor(c4);
    186:   {
    187:     int x = XTRANS(draw,img,xl), w = XTRANS(draw,img,xr) + 1 - x;
    188:     int y = YTRANS(draw,img,yr), h = YTRANS(draw,img,yl) + 1 - y;
    189:     int c  = (c1 + c2 + c3 + c4)/4;
    190:     PetscImageDrawRectangle(img,x,y,w,h,c);
    191:   }
    192:   return(0);
    193: }

    197: static PetscErrorCode PetscDrawEllipse_Image(PetscDraw draw,PetscReal x,PetscReal y,PetscReal a,PetscReal b,int c)
    198: {
    199:   PetscImage img = (PetscImage)draw->data;
    201:   PetscDrawValidColor(c);
    202:   a = PetscAbsReal(a);
    203:   b = PetscAbsReal(b);
    204:   {
    205:     int xc = XTRANS(draw,img,x), w = XTRANS(draw,img,x + a/2) + 0 - xc;
    206:     int yc = YTRANS(draw,img,y), h = YTRANS(draw,img,y - b/2) + 0 - yc;
    207:     if (PetscAbsReal(a-b) <= 0)  w = h = PetscMin(w,h); /* workaround truncation errors */
    208:     PetscImageDrawEllipse(img,xc,yc,w,h,c);
    209:   }
    210:   return(0);
    211: }

    215: 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)
    216: {
    217:   PetscImage img = (PetscImage)draw->data;
    219:   PetscDrawValidColor(c1);
    220:   PetscDrawValidColor(c2);
    221:   PetscDrawValidColor(c3);
    222:   {
    223:     int x_1 = XTRANS(draw,img,X_1), x_2 = XTRANS(draw,img,X_2), x_3 = XTRANS(draw,img,X_3);
    224:     int y_1 = YTRANS(draw,img,Y_1), y_2 = YTRANS(draw,img,Y_2), y_3 = YTRANS(draw,img,Y_3);
    225:     PetscImageDrawTriangle(img,x_1,y_1,c1,x_2,y_2,c2,x_3,y_3,c3);
    226:   }
    227:   return(0);
    228: }

    230: /*
    233: static PetscErrorCode PetscDrawStringSetSize_Image(PetscDraw draw,PetscReal w,PetscReal h)
    234: {
    236:   return(0);
    237: }*/
    238: #define PetscDrawStringSetSize_Image NULL

    242: static PetscErrorCode PetscDrawStringGetSize_Image(PetscDraw draw,PetscReal *w,PetscReal  *h)
    243: {
    244:   PetscImage img = (PetscImage)draw->data;
    246:   {
    247:     int tw = PetscImageFontWidth;
    248:     int th = PetscImageFontHeight;
    249:     if (w) *w = tw*(draw->coor_xr - draw->coor_xl)/(img->w*(draw->port_xr - draw->port_xl));
    250:     if (h) *h = th*(draw->coor_yr - draw->coor_yl)/(img->h*(draw->port_yr - draw->port_yl));
    251:   }
    252:   return(0);
    253: }

    257: static PetscErrorCode PetscDrawString_Image(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])
    258: {
    259:   PetscImage     img = (PetscImage)draw->data;
    260:   PetscToken     token;
    261:   char           *subtext;
    264:   PetscDrawValidColor(c);
    265:   {
    266:     int xx = XTRANS(draw,img,x);
    267:     int yy = YTRANS(draw,img,y);
    268:     PetscTokenCreate(text,'\n',&token);
    269:     PetscTokenFind(token,&subtext);
    270:     while (subtext) {
    271:       PetscImageDrawText(img,xx,yy,c,subtext);
    272:       yy += PetscImageFontHeight;
    273:       PetscTokenFind(token,&subtext);
    274:     }
    275:     PetscTokenDestroy(&token);
    276:   }
    277:   return(0);
    278: }

    282: static PetscErrorCode PetscDrawStringVertical_Image(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])
    283: {
    284:   PetscImage img = (PetscImage)draw->data;
    286:   PetscDrawValidColor(c);
    287:   {
    288:     char chr[2] = {0, 0};
    289:     int  xx = XTRANS(draw,img,x);
    290:     int  yy = YTRANS(draw,img,y);
    291:     int  offset = PetscImageFontHeight;
    292:     while ((chr[0] = *text++)) {
    293:       PetscImageDrawText(img,xx,yy+offset,c,chr);
    294:       yy += PetscImageFontHeight;
    295:     }
    296:   }
    297:   return(0);
    298: }

    300: /*
    303: static PetscErrorCode PetscDrawStringBoxed_Image(PetscDraw draw,PetscReal sxl,PetscReal syl,int sc,int bc,const char text[],PetscReal *w,PetscReal *h)
    304: {
    306:   if (w) *w = 0;
    307:   if (h) *h = 0;
    308:   return(0);
    309: */
    310: #define PetscDrawStringBoxed_Image NULL

    312: /*
    315: static PetscErrorCode PetscDrawFlush_Image(PetscDraw draw)
    316: {
    318:   return(0);
    319: }*/
    320: #define PetscDrawFlush_Image NULL

    324: static PetscErrorCode PetscDrawClear_Image(PetscDraw draw)
    325: {
    326:   PetscImage     img = (PetscImage)draw->data;
    328:   {
    329:     PetscImageClear(img);
    330:   }
    331:   return(0);
    332: }

    334: /*
    337: static PetscErrorCode PetscDrawSetDoubleBuffer_Image(PetscDraw draw)
    338: {
    340:   return(0);
    341: }*/
    342: #define PetscDrawSetDoubleBuffer_Image NULL

    346: static PetscErrorCode PetscDrawGetPopup_Image(PetscDraw draw,PetscDraw *popup)
    347: {
    348:   PetscBool      flg = PETSC_FALSE;

    352:   PetscOptionsGetBool(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_popup",&flg,NULL);
    353:   if (!flg) {*popup = NULL; return(0);}
    354:   PetscDrawCreate(PetscObjectComm((PetscObject)draw),NULL,NULL,0,0,220,220,popup);
    355:   PetscDrawSetType(*popup,PETSC_DRAW_IMAGE);
    356:   PetscObjectSetOptionsPrefix((PetscObject)*popup,"popup_");
    357:   PetscObjectAppendOptionsPrefix((PetscObject)*popup,((PetscObject)draw)->prefix);
    358:   draw->popup = *popup;
    359:   return(0);
    360: }

    362: /*
    365: static PetscErrorCode PetscDrawSetTitle_Image(PetscDraw draw,const char title[])
    366: {
    368:   return(0);
    369: }*/
    370: #define PetscDrawSetTitle_Image NULL

    372: /*
    375: static PetscErrorCode PetscDrawCheckResizedWindow_Image(PetscDraw draw)
    376: {
    378:   return(0);
    379: }*/
    380: #define PetscDrawCheckResizedWindow_Image NULL

    384: static PetscErrorCode PetscDrawResizeWindow_Image(PetscDraw draw,int w,int h)
    385: {
    386:   PetscImage     img = (PetscImage)draw->data;

    390:   if (w == img->w && h == img->h) return(0);
    391:   PetscFree(img->buffer);

    393:   img->w = w; img->h = h;
    394:   PetscCalloc1((size_t)(img->w*img->h),&img->buffer);
    395:   PetscDrawSetViewport_Image(draw,draw->port_xl,draw->port_yl,draw->port_xr,draw->port_yr);
    396:   return(0);
    397: }

    401: static PetscErrorCode PetscDrawDestroy_Image(PetscDraw draw)
    402: {
    403:   PetscImage     img = (PetscImage)draw->data;

    407:   PetscDrawDestroy(&draw->popup);
    408:   PetscFree(img->buffer);
    409:   PetscFree(draw->data);
    410:   return(0);
    411: }

    413: /*
    416: static PetscErrorCode PetscDrawView_Image(PetscDraw draw,PetscViewer viewer)
    417: {
    419:   return(0);
    420: }*/
    421: #define PetscDrawView_Image NULL

    423: /*
    426: static PetscErrorCode PetscDrawGetMouseButton_Image(PetscDraw draw,PetscDrawButton *button,PetscReal *x_user,PetscReal *y_user,PetscReal *x_phys,PetscReal *y_phys)
    427: {
    429:   *button = PETSC_BUTTON_NONE;
    430:   if (x_user) *x_user = 0;
    431:   if (y_user) *y_user = 0;
    432:   if (x_phys) *x_phys = 0;
    433:   if (y_phys) *y_phys = 0;
    434:   return(0);
    435: }*/
    436: #define PetscDrawGetMouseButton_Image NULL

    438: /*
    441: static PetscErrorCode PetscDrawPause_Image(PetscDraw draw)
    442: {
    444:   return(0);
    445: }*/
    446: #define PetscDrawPause_Image NULL

    448: /*
    451: static PetscErrorCode PetscDrawBeginPage_Image(PetscDraw draw)
    452: {
    454:   return(0);
    455: }*/
    456: #define PetscDrawBeginPage_Image NULL

    458: /*
    461: static PetscErrorCode PetscDrawEndPage_Image(PetscDraw draw)
    462: {
    464:   return(0);
    465: }*/
    466: #define PetscDrawEndPage_Image NULL

    470: static PetscErrorCode PetscDrawGetSingleton_Image(PetscDraw draw,PetscDraw *sdraw)
    471: {
    472:   PetscImage     pimg = (PetscImage)draw->data;
    473:   PetscImage     simg;

    477:   PetscDrawCreate(PETSC_COMM_SELF,NULL,NULL,0,0,draw->w,draw->h,sdraw);
    478:   PetscDrawSetType(*sdraw,PETSC_DRAW_IMAGE);
    479:   (*sdraw)->ops->resizewindow = NULL;
    480:   simg = (PetscImage)(*sdraw)->data;
    481:   PetscMemcpy(simg->buffer,pimg->buffer,(size_t)(pimg->w*pimg->h));
    482:   return(0);
    483: }

    487: static PetscErrorCode PetscDrawRestoreSingleton_Image(PetscDraw draw,PetscDraw *sdraw)
    488: {
    489:   PetscImage     pimg = (PetscImage)draw->data;
    490:   PetscImage     simg = (PetscImage)(*sdraw)->data;

    494:   PetscMemcpy(pimg->buffer,simg->buffer,(size_t)(pimg->w*pimg->h));
    495:   PetscDrawDestroy(sdraw);
    496:   return(0);
    497: }

    499: /*
    502: static PetscErrorCode PetscDrawSave_Image(PetscDraw draw)
    503: {
    505:   return(0);
    506: }*/
    507: #define PetscDrawSave_Image NULL

    511: static PetscErrorCode PetscDrawGetImage_Image(PetscDraw draw,unsigned char palette[256][3],unsigned int *w,unsigned int *h,unsigned char *pixels[])
    512: {
    513:   PetscImage     img = (PetscImage)draw->data;
    514:   unsigned char  *buffer = NULL;
    515:   PetscMPIInt    rank,size;

    519:   if (w) *w = (unsigned int)img->w;
    520:   if (h) *h = (unsigned int)img->h;
    521:   if (pixels) *pixels = NULL;
    522:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
    523:   if (!rank) {
    524:     PetscMemcpy(palette,img->palette,sizeof(img->palette));
    525:     PetscMalloc1((size_t)(img->w*img->h),&buffer);
    526:     if (pixels) *pixels = buffer;
    527:   }
    528:   MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
    529:   if (size == 1) {
    530:     PetscMemcpy(buffer,img->buffer,(size_t)(img->w*img->h));
    531:   } else {
    532:     MPI_Reduce(img->buffer,buffer,img->w*img->h,MPI_UNSIGNED_CHAR,MPI_MAX,0,PetscObjectComm((PetscObject)draw));
    533:   }
    534:   return(0);
    535: }

    537: static struct _PetscDrawOps DvOps = {
    538:   PetscDrawSetDoubleBuffer_Image,
    539:   PetscDrawFlush_Image,
    540:   PetscDrawLine_Image,
    541:   PetscDrawLineSetWidth_Image,
    542:   PetscDrawLineGetWidth_Image,
    543:   PetscDrawPoint_Image,
    544:   PetscDrawPointSetSize_Image,
    545:   PetscDrawString_Image,
    546:   PetscDrawStringVertical_Image,
    547:   PetscDrawStringSetSize_Image,
    548:   PetscDrawStringGetSize_Image,
    549:   PetscDrawSetViewport_Image,
    550:   PetscDrawClear_Image,
    551:   PetscDrawRectangle_Image,
    552:   PetscDrawTriangle_Image,
    553:   PetscDrawEllipse_Image,
    554:   PetscDrawGetMouseButton_Image,
    555:   PetscDrawPause_Image,
    556:   PetscDrawBeginPage_Image,
    557:   PetscDrawEndPage_Image,
    558:   PetscDrawGetPopup_Image,
    559:   PetscDrawSetTitle_Image,
    560:   PetscDrawCheckResizedWindow_Image,
    561:   PetscDrawResizeWindow_Image,
    562:   PetscDrawDestroy_Image,
    563:   PetscDrawView_Image,
    564:   PetscDrawGetSingleton_Image,
    565:   PetscDrawRestoreSingleton_Image,
    566:   PetscDrawSave_Image,
    567:   PetscDrawGetImage_Image,
    568:   PetscDrawSetCoordinates_Image,
    569:   PetscDrawArrow_Image,
    570:   PetscDrawCoordinateToPixel_Image,
    571:   PetscDrawPixelToCoordinate_Image,
    572:   PetscDrawPointPixel_Image,
    573:   PetscDrawStringBoxed_Image
    574: };

    576: static const unsigned char BasicColors[PETSC_DRAW_BASIC_COLORS][3] = {
    577:   { 255, 255, 255 }, /* white */
    578:   {   0,   0,   0 }, /* black */
    579:   { 255,   0,   0 }, /* red */
    580:   {   0, 255,   0 }, /* green */
    581:   {   0, 255, 255 }, /* cyan */
    582:   {   0,   0, 255 }, /* blue */
    583:   { 255,   0, 255 }, /* magenta */
    584:   { 127, 255, 212 }, /* aquamarine */
    585:   {  34, 139,  34 }, /* forestgreen */
    586:   { 255, 165,   0 }, /* orange */
    587:   { 238, 130, 238 }, /* violet */
    588:   { 165,  42,  42 }, /* brown */
    589:   { 255, 192, 203 }, /* pink */
    590:   { 255, 127,  80 }, /* coral */
    591:   { 190, 190, 190 }, /* gray */
    592:   { 255, 255,   0 }, /* yellow */
    593:   { 255, 215,   0 }, /* gold */
    594:   { 255, 182, 193 }, /* lightpink */
    595:   {  72, 209, 204 }, /* mediumturquoise */
    596:   { 240, 230, 140 }, /* khaki */
    597:   { 105, 105, 105 }, /* dimgray */
    598:   {  54, 205,  50 }, /* yellowgreen */
    599:   { 135, 206, 235 }, /* skyblue */
    600:   {   0, 100,   0 }, /* darkgreen */
    601:   {   0,   0, 128 }, /* navyblue */
    602:   { 244, 164,  96 }, /* sandybrown */
    603:   {  95, 158, 160 }, /* cadetblue */
    604:   { 176, 224, 230 }, /* powderblue */
    605:   { 255,  20, 147 }, /* deeppink */
    606:   { 216, 191, 216 }, /* thistle */
    607:   {  50, 205,  50 }, /* limegreen */
    608:   { 255, 240, 245 }, /* lavenderblush */
    609:   { 221, 160, 221 }, /* plum */
    610: };

    613: /*MC
    614:    PETSC_DRAW_IMAGE - PETSc graphics device that uses a raster buffer

    616:    Options Database Keys:
    617: .  -draw_size w,h - size of image in pixels

    619:    Level: beginner

    621: .seealso:  PetscDrawOpenImage(), PetscDrawSetFromOptions()
    622: M*/
    623: PETSC_EXTERN PetscErrorCode PetscDrawCreate_Image(PetscDraw);

    627: PETSC_EXTERN PetscErrorCode PetscDrawCreate_Image(PetscDraw draw)
    628: {
    629:   PetscImage     img;
    630:   int            w = draw->w, h = draw->h;
    631:   PetscInt       size[2], nsize = 2;
    632:   PetscBool      set;

    636:   draw->pause   = 0;
    637:   draw->coor_xl = 0; draw->coor_xr = 1;
    638:   draw->coor_yl = 0; draw->coor_yr = 1;
    639:   draw->port_xl = 0; draw->port_xr = 1;
    640:   draw->port_yl = 0; draw->port_yr = 1;

    642:   size[0] = w; if (size[0] < 1) size[0] = 300;
    643:   size[1] = h; if (size[1] < 1) size[1] = size[0];
    644:   PetscOptionsGetIntArray(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_size",size,&nsize,&set);
    645:   if (set && nsize == 1) size[1] = size[0];
    646:   if (size[0] < 1) size[0] = 300;
    647:   if (size[1] < 1) size[1] = size[0];
    648:   draw->w = w = size[0]; draw->x = 0;
    649:   draw->h = h = size[1]; draw->x = 0;

    651:   PetscNewLog(draw,&img);
    652:   PetscMemcpy(draw->ops,&DvOps,sizeof(DvOps));
    653:   draw->data = (void*)img;

    655:   img->w = w; img->h = h;
    656:   PetscCalloc1((size_t)(img->w*img->h),&img->buffer);
    657:   PetscImageSetClip(img,0,0,img->w,img->h);
    658:   {
    659:     int i,k,ncolors = 256-PETSC_DRAW_BASIC_COLORS;
    660:     unsigned char R[256-PETSC_DRAW_BASIC_COLORS];
    661:     unsigned char G[256-PETSC_DRAW_BASIC_COLORS];
    662:     unsigned char B[256-PETSC_DRAW_BASIC_COLORS];
    663:     PetscDrawUtilitySetCmap(NULL,ncolors,R,G,B);
    664:     for (k=0; k<PETSC_DRAW_BASIC_COLORS; k++) {
    665:       img->palette[k][0] = BasicColors[k][0];
    666:       img->palette[k][1] = BasicColors[k][1];
    667:       img->palette[k][2] = BasicColors[k][2];
    668:     }
    669:     for (i=0; i<ncolors; i++, k++) {
    670:       img->palette[k][0] = R[i];
    671:       img->palette[k][1] = G[i];
    672:       img->palette[k][2] = B[i];
    673:     }
    674:   }

    676:   if (!draw->savefilename ){PetscDrawSetSave(draw,"");}
    677:   return(0);
    678: }

    682: /*@C
    683:    PetscDrawOpenImage - Opens an image for use with the PetscDraw routines.

    685:    Collective on MPI_Comm

    687:    Input Parameters:
    688: +  comm - the communicator that will share image
    689: -  filename - optional name of the file
    690: -  w, h - the image width and height in pixels

    692:    Output Parameters:
    693: .  draw - the drawing context.

    695:    Level: beginner

    697: .seealso: PetscDrawSetSave(), PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
    698: @*/
    699: PetscErrorCode PetscDrawOpenImage(MPI_Comm comm,const char filename[],int w,int h,PetscDraw *draw)
    700: {

    704:   PetscDrawCreate(comm,NULL,NULL,0,0,w,h,draw);
    705:   PetscDrawSetType(*draw,PETSC_DRAW_IMAGE);
    706:   PetscDrawSetSave(*draw,filename);
    707:   return(0);
    708: }