Date: 2015-10-02T21:58:50+00:00

Actual source code: drawreg.c
petsc-3.6.2 2015-10-02
Report Typos and Errors

      2: /*
      3:        Provides the registration process for PETSc PetscDraw routines
      4: */
      5: #include <petsc/private/drawimpl.h>  /*I "petscdraw.h" I*/
      6: #include <petscviewer.h>             /*I "petscviewer.h" I*/
      7: #if defined(PETSC_HAVE_SAWS)
      8: #include <petscviewersaws.h>
      9: #endif

     11: /*
     12:    Contains the list of registered PetscDraw routines
     13: */
     14: PetscFunctionList PetscDrawList = 0;

     18: /*@C
     19:    PetscDrawView - Prints the PetscDraw data structure.

     21:    Collective on PetscDraw

     23:    Input Parameters:
     24: +  indraw - the PetscDraw context
     25: -  viewer - visualization context

     27:    See PetscDrawSetFromOptions() for options database keys

     29:    Note:
     30:    The available visualization contexts include
     31: +     PETSC_VIEWER_STDOUT_SELF - standard output (default)
     32: -     PETSC_VIEWER_STDOUT_WORLD - synchronized standard
     33:          output where only the first processor opens
     34:          the file.  All other processors send their
     35:          data to the first processor to print.

     37:    The user can open an alternative visualization context with
     38:    PetscViewerASCIIOpen() - output to a specified file.

     40:    Level: beginner

     42: .keywords: PetscDraw, view

     44: .seealso: PCView(), PetscViewerASCIIOpen()
     45: @*/
     46: PetscErrorCode  PetscDrawView(PetscDraw indraw,PetscViewer viewer)
     47: {
     49:   PetscBool      isdraw;
     50: #if defined(PETSC_HAVE_SAWS)
     51:   PetscBool      issaws;
     52: #endif

     56:   if (!viewer) viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)indraw));

     60:   PetscObjectPrintClassNamePrefixType((PetscObject)indraw,viewer);
     61:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);
     62: #if defined(PETSC_HAVE_SAWS)
     63:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSAWS,&issaws);
     64: #endif
     65:   if (isdraw) {
     66:     PetscDraw draw;
     67:     char      str[36];
     68:     PetscReal x,y,bottom,h;

     70:     PetscViewerDrawGetDraw(viewer,0,&draw);
     71:     PetscDrawGetCurrentPoint(draw,&x,&y);
     72:     PetscStrcpy(str,"PetscDraw: ");
     73:     PetscStrcat(str,((PetscObject)indraw)->type_name);
     74:     PetscDrawStringBoxed(draw,x,y,PETSC_DRAW_RED,PETSC_DRAW_BLACK,str,NULL,&h);
     75:     bottom = y - h;
     76:     PetscDrawPushCurrentPoint(draw,x,bottom);
     77: #if defined(PETSC_HAVE_SAWS)
     78:   } else if (issaws) {
     79:     PetscMPIInt rank;

     81:     PetscObjectName((PetscObject)indraw);
     82:     MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
     83:     if (!((PetscObject)indraw)->amsmem && !rank) {
     84:       PetscObjectViewSAWs((PetscObject)indraw,viewer);
     85:     }
     86: #endif
     87:   } else if (indraw->ops->view) {
     88:     (*indraw->ops->view)(indraw,viewer);
     89:   }
     90:   return(0);
     91: }

     95: /*@C
     96:    PetscDrawCreate - Creates a graphics context.

     98:    Collective on MPI_Comm

    100:    Input Parameter:
    101: +  comm - MPI communicator
    102: .  display - X display when using X windows
    103: .  title - optional title added to top of window
    104: .  x,y - coordinates of lower left corner of window or PETSC_DECIDE
    105: -  w, h - width and height of window or PETSC_DECIDE or PETSC_DRAW_HALF_SIZE, PETSC_DRAW_FULL_SIZE,
    106:           or PETSC_DRAW_THIRD_SIZE or PETSC_DRAW_QUARTER_SIZE

    108:    Output Parameter:
    109: .  draw - location to put the PetscDraw context

    111:    Level: beginner

    113:    Concepts: graphics^creating context
    114:    Concepts: drawing^creating context

    116: .seealso: PetscDrawSetFromOptions(), PetscDrawDestroy(), PetscDrawSetType()
    117: @*/
    118: PetscErrorCode  PetscDrawCreate(MPI_Comm comm,const char display[],const char title[],int x,int y,int w,int h,PetscDraw *indraw)
    119: {
    120:   PetscDraw      draw;
    122:   PetscReal      dpause;
    123:   PetscBool      flag;

    126:   PetscDrawInitializePackage();
    127:   *indraw = 0;
    128:   PetscHeaderCreate(draw,PETSC_DRAW_CLASSID,"Draw","Graphics","Draw",comm,PetscDrawDestroy,PetscDrawView);

    130:   draw->data    = 0;
    131:   PetscStrallocpy(title,&draw->title);
    132:   PetscStrallocpy(display,&draw->display);
    133:   draw->x       = x;
    134:   draw->y       = y;
    135:   draw->w       = w;
    136:   draw->h       = h;
    137:   draw->pause   = 0.0;
    138:   draw->coor_xl = 0.0;
    139:   draw->coor_xr = 1.0;
    140:   draw->coor_yl = 0.0;
    141:   draw->coor_yr = 1.0;
    142:   draw->port_xl = 0.0;
    143:   draw->port_xr = 1.0;
    144:   draw->port_yl = 0.0;
    145:   draw->port_yr = 1.0;
    146:   draw->popup   = 0;

    148:   PetscOptionsGetReal(NULL,"-draw_pause",&dpause,&flag);
    149:   if (flag) draw->pause = dpause;
    150:   draw->savefilename  = NULL;
    151:   draw->savefilemovie = PETSC_FALSE;
    152:   draw->savefilecount = -1;

    154:   PetscDrawSetCurrentPoint(draw,.5,.9);

    156:   draw->boundbox_xl  = .5;
    157:   draw->boundbox_xr  = .5;
    158:   draw->boundbox_yl  = .9;
    159:   draw->boundbox_yr  = .9;

    161:   *indraw = draw;
    162:   return(0);
    163: }

    167: /*@C
    168:    PetscDrawSetType - Builds graphics object for a particular implementation

    170:    Collective on PetscDraw

    172:    Input Parameter:
    173: +  draw      - the graphics context
    174: -  type      - for example, PETSC_DRAW_X

    176:    Options Database Command:
    177: .  -draw_type  <type> - Sets the type; use -help for a list of available methods (for instance, x)

    179:    See PetscDrawSetFromOptions for additional options database keys

    181:    Level: intermediate

    183:    Notes:
    184:    See "petsc/include/petscdraw.h" for available methods (for instance,
    185:    PETSC_DRAW_X)

    187:    Concepts: drawing^X windows
    188:    Concepts: X windows^graphics
    189:    Concepts: drawing^Microsoft Windows

    191: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
    192: @*/
    193: PetscErrorCode  PetscDrawSetType(PetscDraw draw,PetscDrawType type)
    194: {
    195:   PetscErrorCode ierr,(*r)(PetscDraw);
    196:   PetscBool      match;
    197:   PetscBool      flg=PETSC_FALSE;

    203:   PetscObjectTypeCompare((PetscObject)draw,type,&match);
    204:   if (match) return(0);

    206:   /*  User requests no graphics */
    207:   PetscOptionsHasName(NULL,"-nox",&flg);

    209:   /*
    210:      This is not ideal, but it allows codes to continue to run if X graphics
    211:    was requested but is not installed on this machine. Mostly this is for
    212:    testing.
    213:    */
    214: #if !defined(PETSC_HAVE_X)
    215:   if (!flg) {
    216:     PetscStrcmp(type,PETSC_DRAW_X,&match);
    217:     if (match) {
    218:       PetscBool dontwarn = PETSC_TRUE;
    219:       flg  = PETSC_TRUE;
    220:       PetscOptionsHasName(NULL,"-nox_warning",&dontwarn);
    221:       if (!dontwarn) (*PetscErrorPrintf)("PETSc installed without X windows on this machine\nproceeding without graphics\n");
    222:     }
    223:   }
    224: #endif
    225:   if (flg) type = PETSC_DRAW_NULL;

    227:    PetscFunctionListFind(PetscDrawList,type,&r);
    228:   if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PetscDraw type given: %s",type);
    229:   if (draw->ops->destroy) {(*draw->ops->destroy)(draw);}
    230:   PetscMemzero(draw->ops,sizeof(struct _PetscDrawOps));
    231:   PetscObjectChangeTypeName((PetscObject)draw,type);
    232:   (*r)(draw);
    233:   return(0);
    234: }

    238: /*@C
    239:    PetscDrawGetType - Gets the PetscDraw type as a string from the PetscDraw object.

    241:    Not Collective

    243:    Input Parameter:
    244: .  draw - Krylov context

    246:    Output Parameters:
    247: .  name - name of PetscDraw method

    249:    Level: advanced

    251: @*/
    252: PetscErrorCode  PetscDrawGetType(PetscDraw draw,PetscDrawType *type)
    253: {
    257:   *type = ((PetscObject)draw)->type_name;
    258:   return(0);
    259: }

    263: /*@C
    264:    PetscDrawRegister - Adds a method to the graphics package.

    266:    Not Collective

    268:    Input Parameters:
    269: +  name_solver - name of a new user-defined graphics class
    270: -  routine_create - routine to create method context

    272:    Level: developer

    274:    Notes:
    275:    PetscDrawRegister() may be called multiple times to add several user-defined graphics classes

    277:    Sample usage:
    278: .vb
    279:    PetscDrawRegister("my_draw_type", MyDrawCreate);
    280: .ve

    282:    Then, your specific graphics package can be chosen with the procedural interface via
    283: $     PetscDrawSetType(ksp,"my_draw_type")
    284:    or at runtime via the option
    285: $     -draw_type my_draw_type

    287:    Concepts: graphics^registering new draw classes
    288:    Concepts: PetscDraw^registering new draw classes

    290: .seealso: PetscDrawRegisterAll(), PetscDrawRegisterDestroy()
    291: @*/
    292: PetscErrorCode  PetscDrawRegister(const char *sname,PetscErrorCode (*function)(PetscDraw))
    293: {

    297:   PetscFunctionListAdd(&PetscDrawList,sname,function);
    298:   return(0);
    299: }

    303: /*@
    304:    PetscDrawSetFromOptions - Sets the graphics type from the options database.
    305:       Defaults to a PETSc X windows graphics.

    307:    Collective on PetscDraw

    309:    Input Parameter:
    310: .     draw - the graphics context

    312:    Options Database Keys:
    313: +   -nox - do not use X graphics (ignore graphics calls, but run program correctly)
    314: .   -nox_warning - when X windows support is not installed this prevents the warning message from being printed
    315: .   -draw_pause <pause amount> -- -1 indicates wait for mouse input, -2 indicates pause when window is to be destroyed
    316: .   -draw_marker_type - <x,point>
    317: .   -draw_save [optional filename] - (X windows only) saves each image before it is cleared to a file
    318: .   -draw_save_final_image [optional filename] - (X windows only) saves the final image displayed in a window
    319: .   -draw_save_movie - converts image files to a movie  at the end of the run. See PetscDrawSetSave()
    320: .   -draw_save_on_flush - saves an image on each flush in addition to each clear
    321: -   -draw_save_single_file - saves each new image in the same file, normally each new image is saved in a new file with filename_%d

    323:    Level: intermediate

    325:    Notes:
    326:     Must be called after PetscDrawCreate() before the PetscDraw is used.

    328:     Concepts: drawing^setting options
    329:     Concepts: graphics^setting options

    331: .seealso: PetscDrawCreate(), PetscDrawSetType(), PetscDrawSetSave(), PetscDrawSetSaveFinalImage()

    333: @*/
    334: PetscErrorCode  PetscDrawSetFromOptions(PetscDraw draw)
    335: {
    336:   PetscErrorCode    ierr;
    337:   PetscBool         flg,nox;
    338:   char              vtype[256];
    339:   const char        *def;
    340:   PetscReal         dpause;
    341: #if !defined(PETSC_USE_WINDOWS_GRAPHICS) && !defined(PETSC_HAVE_X)
    342:   PetscBool         warn;
    343: #endif

    348:   if (!PetscDrawList) {
    349:     PetscDrawRegisterAll();
    350:   }

    352:   if (((PetscObject)draw)->type_name) def = ((PetscObject)draw)->type_name;
    353:   else {
    354:     PetscOptionsHasName(NULL,"-nox",&nox);
    355:     def  = PETSC_DRAW_NULL;
    356: #if defined(PETSC_USE_WINDOWS_GRAPHICS)
    357:     if (!nox) def = PETSC_DRAW_WIN32;
    358: #elif defined(PETSC_HAVE_X)
    359:     if (!nox) def = PETSC_DRAW_X;
    360: #elif defined(PETSC_HAVE_GLUT)
    361:     if (!nox) def = PETSC_DRAW_GLUT;
    362: #elif defined(PETSC_HAVE_OPENGLES)
    363:     if (!nox) def = PETSC_DRAW_OPENGLES;
    364: #else
    365:     PetscOptionsHasName(NULL,"-nox_warning",&warn);
    366:     if (!nox && !warn) (*PetscErrorPrintf)("PETSc installed without X windows, Microsoft Graphics, OpenGL ES, or GLUT/OpenGL on this machine\nproceeding without graphics\n");
    367: #endif
    368:   }
    369:   PetscObjectOptionsBegin((PetscObject)draw);
    370:   PetscOptionsFList("-draw_type","Type of graphical output","PetscDrawSetType",PetscDrawList,def,vtype,256,&flg);
    371:   if (flg) {
    372:     PetscDrawSetType(draw,vtype);
    373:   } else if (!((PetscObject)draw)->type_name) {
    374:     PetscDrawSetType(draw,def);
    375:   }
    376:   PetscOptionsName("-nox","Run without graphics","None",&nox);
    377: #if defined(PETSC_HAVE_X)
    378:   {
    379:     char      filename[PETSC_MAX_PATH_LEN];
    380:     PetscBool save,movie = PETSC_FALSE;
    381:     PetscOptionsBool("-draw_save_movie","Make a movie from the images saved (X Windows only)","PetscDrawSetSave",movie,&movie,NULL);
    382:     PetscOptionsBool("-draw_save_single_file","Each new image replaces previous image in file","PetscDrawSetSave",draw->savesinglefile,&draw->savesinglefile,NULL);
    383:     PetscOptionsString("-draw_save","Save graphics to file (X Windows only)","PetscDrawSetSave",filename,filename,PETSC_MAX_PATH_LEN,&save);
    384:     if (save) {
    385:       PetscDrawSetSave(draw,filename,movie);
    386:     }
    387:     PetscOptionsString("-draw_save_final_image","Save graphics to file (X Windows only)","PetscDrawSetSaveFinalImage",filename,filename,PETSC_MAX_PATH_LEN,&save);
    388:     if (save) {
    389:       PetscDrawSetSaveFinalImage(draw,filename);
    390:     }
    391:     PetscOptionsBool("-draw_save_on_flush","Save graphics to file (X Windows only) on each flush","PetscDrawSetSave",draw->saveonflush,&draw->saveonflush,NULL);
    392:   }
    393: #endif
    394:   PetscOptionsGetReal(NULL,"-draw_pause",&dpause,&flg);
    395:   if (flg) draw->pause = dpause;

    397:   PetscOptionsEnum("-draw_marker_type","Type of marker to use on plots","PetscDrawSetMarkerType",PetscDrawMarkerTypes,(PetscEnum)draw->markertype,(PetscEnum *)&draw->markertype,NULL);

    399:   /* process any options handlers added with PetscObjectAddOptionsHandler() */
    400:   PetscObjectProcessOptionsHandlers((PetscObject)draw);

    402:   PetscDrawViewFromOptions(draw,NULL,"-draw_view");
    403:   PetscOptionsEnd();
    404:   return(0);
    405: }

    409: /*@C
    410:    PetscDrawSetSave - Saves images produced in a PetscDraw into a file as a Gif file using AfterImage

    412:    Collective on PetscDraw

    414:    Input Parameter:
    415: +  draw      - the graphics context
    416: .  filename  - name of the file, if .ext then uses name of draw object plus .ext using .ext to determine the image type, if NULL use .Gif image type
    417: -  movie - produce a movie of all the images

    419:    Options Database Command:
    420: +  -draw_save  <filename> - filename could be name.ext or .ext (where .ext determines the type of graphics file to save, for example .Gif)
    421: .  -draw_save_movie
    422: .  -draw_save_final_image [optional filename] - (X windows only) saves the final image displayed in a window
    423: .  -draw_save_on_flush - saves an image on each flush in addition to each clear
    424: -  -draw_save_single_file - saves each new image in the same file, normally each new image is saved in a new file with filename_%d

    426:    Level: intermediate

    428:    Concepts: X windows^graphics

    430:    Notes: You should call this BEFORE calling PetscDrawClear() and creating your image.

    432:    Requires that PETSc be configured with the option --with-afterimage to save the images and ffmpeg must be in your path to make the movie

    434:    The .ext formats that are supported depend on what formats AfterImage was configured with; on the Apple Mac both .Gif and .Jpeg are supported.

    436:    If X windows generates an error message about X_CreateWindow() failing then Afterimage was installed without X windows. Reinstall Afterimage using the
    437:    ./configure flags --x-includes=/pathtoXincludes --x-libraries=/pathtoXlibraries   For example under Mac OS X Mountain Lion --x-includes=/opt/X11/include -x-libraries=/opt/X11/lib

    440: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy(), PetscDrawSetSaveFinalImage()
    441: @*/
    442: PetscErrorCode  PetscDrawSetSave(PetscDraw draw,const char *filename,PetscBool movie)
    443: {
    445:   char           *ext;

    449:   PetscFree(draw->savefilename);

    451:   /* determine extension of filename */
    452:   if (filename && filename[0]) {
    453:     PetscStrchr(filename,'.',&ext);
    454:     if (!ext) SETERRQ1(PetscObjectComm((PetscObject)draw),PETSC_ERR_ARG_INCOMP,"Filename %s should end with graphics extension (for example .Gif)",filename);
    455:   } else {
    456:     ext = (char *)".Gif";
    457:   }
    458:   if (ext == filename) filename = NULL;
    459:   PetscStrallocpy(ext,&draw->savefilenameext);

    461:   draw->savefilemovie = movie;
    462:   if (filename && filename[0]) {
    463:     size_t  l1,l2;
    464:     PetscStrlen(filename,&l1);
    465:     PetscStrlen(ext,&l2);
    466:     PetscMalloc1(l1-l2+1,&draw->savefilename);
    467:     PetscStrncpy(draw->savefilename,filename,l1-l2+1);
    468:   } else {
    469:     const char *name;

    471:     PetscObjectGetName((PetscObject)draw,&name);
    472:     PetscStrallocpy(name,&draw->savefilename);
    473:   }
    474:   PetscInfo2(NULL,"Will save images to file %s%s\n",draw->savefilename,draw->savefilenameext);
    475:   if (draw->ops->setsave) {
    476:     (*draw->ops->setsave)(draw,draw->savefilename);
    477:   }
    478:   return(0);
    479: }

    483: /*@C
    484:    PetscDrawSetSaveFinalImage - Saves the finale image produced in a PetscDraw into a file as a Gif file using AfterImage

    486:    Collective on PetscDraw

    488:    Input Parameter:
    489: +  draw      - the graphics context
    490: -  filename  - name of the file, if NULL uses name of draw object

    492:    Options Database Command:
    493: .  -draw_save_final_image  <filename>

    495:    Level: intermediate

    497:    Concepts: X windows^graphics

    499:    Notes: You should call this BEFORE calling PetscDrawClear() and creating your image.

    501:    Requires that PETSc be configured with the option --with-afterimage to save the images and ffmpeg must be in your path to make the movie

    503:    If X windows generates an error message about X_CreateWindow() failing then Afterimage was installed without X windows. Reinstall Afterimage using the
    504:    ./configure flags --x-includes=/pathtoXincludes --x-libraries=/pathtoXlibraries   For example under Mac OS X Mountain Lion --x-includes=/opt/X11/include -x-libraries=/opt/X11/lib

    507: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy(), PetscDrawSetSave()
    508: @*/
    509: PetscErrorCode  PetscDrawSetSaveFinalImage(PetscDraw draw,const char *filename)
    510: {

    515:   PetscFree(draw->savefinalfilename);

    517:   if (filename && filename[0]) {
    518:     PetscStrallocpy(filename,&draw->savefinalfilename);
    519:   } else {
    520:     const char *name;
    521:     PetscObjectGetName((PetscObject)draw,&name);
    522:     PetscStrallocpy(name,&draw->savefinalfilename);
    523:   }
    524:   return(0);
    525: }