Actual source code: dsave.c

      1: #include <petsc/private/drawimpl.h>

      3: PETSC_EXTERN PetscErrorCode PetscDrawImageSave(const char[], const char[], unsigned char[][3], unsigned int, unsigned int, const unsigned char[]);
      4: PETSC_EXTERN PetscErrorCode PetscDrawMovieSave(const char[], PetscInt, const char[], PetscInt, const char[]);
      5: PETSC_EXTERN PetscErrorCode PetscDrawImageCheckFormat(const char *[]);
      6: PETSC_EXTERN PetscErrorCode PetscDrawMovieCheckFormat(const char *[]);

      8: #if defined(PETSC_HAVE_SAWS)
      9: static PetscErrorCode PetscDrawSave_SAWs(PetscDraw);
     10: #endif

     12: /*@
     13:   PetscDrawSetSave - Saves images produced in a `PetscDraw` into a file

     15:   Collective

     17:   Input Parameters:
     18: + draw     - the graphics context
     19: - filename - name of the file, if .ext then uses name of draw object plus .ext using .ext to determine the image type

     21:   Options Database Keys:
     22: + -draw_save <filename>                      - filename could be name.ext or .ext (where .ext determines the type of graphics file to save, for example .png)
     23: . -draw_save_final_image [optional filename] - saves the final image displayed in a window
     24: - -draw_save_single_file                     - saves each new image in the same file, normally each new image is saved in a new file with filename/filename_%d.ext

     26:   Level: intermediate

     28:   Note:
     29:   You should call this BEFORE creating your image and calling `PetscDrawSave()`.
     30:   The supported image types are .png, .gif, .jpg, and .ppm (PETSc chooses the default in that order).
     31:   Support for .png images requires configure --with-libpng.
     32:   Support for .gif images requires configure --with-giflib.
     33:   Support for .jpg images requires configure --with-libjpeg.
     34:   Support for .ppm images is built-in. The PPM format has no compression (640x480 pixels ~ 900 KiB).

     36: .seealso: `PetscDraw`, `PetscDrawOpenX()`, `PetscDrawOpenImage()`, `PetscDrawSetFromOptions()`, `PetscDrawCreate()`, `PetscDrawDestroy()`, `PetscDrawSetSaveFinalImage()`
     37: @*/
     38: PetscErrorCode PetscDrawSetSave(PetscDraw draw, const char filename[])
     39: {
     40:   const char *savename = NULL;
     41:   const char *imageext = NULL;
     42:   char        buf[PETSC_MAX_PATH_LEN];

     44:   PetscFunctionBegin;
     46:   if (filename) PetscAssertPointer(filename, 2);

     48:   /* determine save filename and image extension */
     49:   if (filename && filename[0]) {
     50:     PetscCall(PetscStrchr(filename, '.', (char **)&imageext));
     51:     if (!imageext) savename = filename;
     52:     else if (imageext != filename) {
     53:       size_t l1 = 0, l2 = 0;
     54:       PetscCall(PetscStrlen(filename, &l1));
     55:       PetscCall(PetscStrlen(imageext, &l2));
     56:       PetscCall(PetscStrncpy(buf, filename, sizeof(buf)));
     57:       buf[l1 - l2 + 1] = '\0';
     58:       savename         = buf;
     59:     }
     60:   }

     62:   if (!savename) PetscCall(PetscObjectGetName((PetscObject)draw, &savename));
     63:   PetscCall(PetscDrawImageCheckFormat(&imageext));

     65:   draw->savefilecount = 0;
     66:   PetscCall(PetscFree(draw->savefilename));
     67:   PetscCall(PetscFree(draw->saveimageext));
     68:   PetscCall(PetscStrallocpy(savename, &draw->savefilename));
     69:   PetscCall(PetscStrallocpy(imageext, &draw->saveimageext));

     71:   if (draw->savesinglefile) {
     72:     PetscCall(PetscInfo(NULL, "Will save image to file %s%s\n", draw->savefilename, draw->saveimageext));
     73:   } else {
     74:     PetscCall(PetscInfo(NULL, "Will save images to file %s/%s_%%d%s\n", draw->savefilename, draw->savefilename, draw->saveimageext));
     75:   }
     76:   PetscFunctionReturn(PETSC_SUCCESS);
     77: }

     79: /*@
     80:   PetscDrawSetSaveMovie - Saves a movie produced from a `PetscDraw` into a file

     82:   Collective

     84:   Input Parameters:
     85: + draw     - the graphics context
     86: - movieext - optional extension defining the movie format

     88:   Options Database Key:
     89: . -draw_save_movie <.ext> - saves a movie with extension .ext

     91:   Level: intermediate

     93:   Note:
     94:   You should call this AFTER calling `PetscDrawSetSave()` and BEFORE creating your image with `PetscDrawSave()`.
     95:   The ffmpeg utility must be in your path to make the movie.

     97: .seealso: `PetscDraw`, `PetscDrawSetSave()`, `PetscDrawSetFromOptions()`, `PetscDrawCreate()`, `PetscDrawDestroy()`
     98: @*/
     99: PetscErrorCode PetscDrawSetSaveMovie(PetscDraw draw, const char movieext[])
    100: {
    101:   PetscFunctionBegin;
    103:   if (movieext) PetscAssertPointer(movieext, 2);

    105:   if (!draw->savefilename) PetscCall(PetscDrawSetSave(draw, ""));
    106:   PetscCall(PetscDrawMovieCheckFormat(&movieext));
    107:   PetscCall(PetscStrallocpy(movieext, &draw->savemovieext));
    108:   draw->savesinglefile = PETSC_FALSE; /* otherwise we cannot generate movies */

    110:   PetscCall(PetscInfo(NULL, "Will save movie to file %s%s\n", draw->savefilename, draw->savemovieext));
    111:   PetscFunctionReturn(PETSC_SUCCESS);
    112: }

    114: /*@
    115:   PetscDrawSetSaveFinalImage - Saves the final image produced in a `PetscDraw` into a file

    117:   Collective

    119:   Input Parameters:
    120: + draw     - the graphics context
    121: - filename - name of the file, if NULL or empty uses name set with `PetscDrawSetSave()` or the name of the draw object

    123:   Options Database Key:
    124: . -draw_save_final_image  <filename> - filename could be name.ext or .ext (where .ext determines the type of graphics file to save, for example .png)

    126:   Level: intermediate

    128:   Notes:
    129:   You should call this BEFORE creating your image and calling `PetscDrawSave()`.

    131:   The supported image types are .png, .gif, and .ppm (PETSc chooses the default in that order).
    132: .vb
    133:    Support for .png images requires configure --with-libpng.
    134:    Support for .gif images requires configure --with-giflib.
    135:    Support for .jpg images requires configure --with-libjpeg.
    136:    Support for .ppm images is built-in. The PPM format has no compression (640x480 pixels ~ 900 KiB).
    137: .ve

    139: .seealso: `PetscDraw`, `PetscDrawSetSave()`, `PetscDrawSetFromOptions()`, `PetscDrawCreate()`, `PetscDrawDestroy()`
    140: @*/
    141: PetscErrorCode PetscDrawSetSaveFinalImage(PetscDraw draw, const char filename[])
    142: {
    143:   char buf[PETSC_MAX_PATH_LEN];

    145:   PetscFunctionBegin;
    147:   if (!filename || !filename[0]) {
    148:     if (!draw->savefilename) {
    149:       PetscCall(PetscObjectGetName((PetscObject)draw, &filename));
    150:     } else {
    151:       PetscCall(PetscSNPrintf(buf, sizeof(buf), "%s%s", draw->savefilename, draw->saveimageext));
    152:       filename = buf;
    153:     }
    154:   }
    155:   PetscCall(PetscFree(draw->savefinalfilename));
    156:   PetscCall(PetscStrallocpy(filename, &draw->savefinalfilename));
    157:   PetscFunctionReturn(PETSC_SUCCESS);
    158: }

    160: /*@
    161:   PetscDrawSave - Saves a drawn image

    163:   Collective

    165:   Input Parameter:
    166: . draw - the drawing context

    168:   Level: advanced

    170:   Note:
    171:   this is not normally called by the user.

    173: .seealso: `PetscDraw`, `PetscDrawSetSave()`
    174: @*/
    175: PetscErrorCode PetscDrawSave(PetscDraw draw)
    176: {
    177:   PetscInt       saveindex;
    178:   char           basename[PETSC_MAX_PATH_LEN];
    179:   unsigned char  palette[256][3];
    180:   unsigned int   w, h;
    181:   unsigned char *pixels = NULL;
    182:   PetscMPIInt    rank;

    184:   PetscFunctionBegin;
    186:   if (!draw->ops->save && !draw->ops->getimage) PetscFunctionReturn(PETSC_SUCCESS);
    187:   if (draw->ops->save) {
    188:     PetscUseTypeMethod(draw, save);
    189:     goto finally;
    190:   }
    191:   if (!draw->savefilename || !draw->saveimageext) PetscFunctionReturn(PETSC_SUCCESS);
    192:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));

    194:   saveindex = draw->savefilecount++;

    196:   if (rank == 0 && !saveindex) {
    197:     char path[PETSC_MAX_PATH_LEN];
    198:     if (draw->savesinglefile) {
    199:       PetscCall(PetscSNPrintf(path, sizeof(path), "%s%s", draw->savefilename, draw->saveimageext));
    200:       (void)remove(path);
    201:     } else {
    202:       PetscCall(PetscSNPrintf(path, sizeof(path), "%s", draw->savefilename));
    203:       PetscCall(PetscRMTree(path));
    204:       PetscCall(PetscMkdir(path));
    205:     }
    206:     if (draw->savemovieext) {
    207:       PetscCall(PetscSNPrintf(path, sizeof(path), "%s%s", draw->savefilename, draw->savemovieext));
    208:       (void)remove(path);
    209:     }
    210:   }
    211:   if (draw->savesinglefile) {
    212:     PetscCall(PetscSNPrintf(basename, sizeof(basename), "%s", draw->savefilename));
    213:   } else {
    214:     char *basefilename = NULL;

    216:     PetscCall(PetscStrrchr(draw->savefilename, '/', &basefilename));
    217:     if (basefilename != draw->savefilename) {
    218:       PetscCall(PetscSNPrintf(basename, sizeof(basename), "%s_%" PetscInt_FMT, draw->savefilename, saveindex));
    219:     } else {
    220:       PetscCall(PetscSNPrintf(basename, sizeof(basename), "%s/%s_%" PetscInt_FMT, draw->savefilename, draw->savefilename, saveindex));
    221:     }
    222:   }

    224:   /* this call is collective, only the first process gets the image data */
    225:   PetscUseTypeMethod(draw, getimage, palette, &w, &h, &pixels);
    226:   /* only the first process handles the saving business */
    227:   if (rank == 0) PetscCall(PetscDrawImageSave(basename, draw->saveimageext, palette, w, h, pixels));
    228:   PetscCall(PetscFree(pixels));
    229:   PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));

    231: finally:
    232: #if defined(PETSC_HAVE_SAWS)
    233:   PetscCall(PetscDrawSave_SAWs(draw));
    234: #endif
    235:   PetscFunctionReturn(PETSC_SUCCESS);
    236: }

    238: /*@
    239:   PetscDrawSaveMovie - Saves a movie from previously saved images

    241:   Collective

    243:   Input Parameter:
    244: . draw - the drawing context

    246:   Level: advanced

    248:   Notes:
    249:   This is not normally called by the user.

    251:   The ffmpeg utility must be in your path to make the movie.

    253: .seealso: `PetscDraw`, `PetscDrawSetSave()`, `PetscDrawSetSaveMovie()`
    254: @*/
    255: PetscErrorCode PetscDrawSaveMovie(PetscDraw draw)
    256: {
    257:   PetscMPIInt rank;

    259:   PetscFunctionBegin;
    261:   if (!draw->ops->save && !draw->ops->getimage) PetscFunctionReturn(PETSC_SUCCESS);
    262:   if (!draw->savefilename || !draw->savemovieext || draw->savesinglefile) PetscFunctionReturn(PETSC_SUCCESS);
    263:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
    264:   {
    265:     const char *fname = draw->savefilename;
    266:     const char *imext = draw->saveimageext;
    267:     const char *mvext = draw->savemovieext;
    268:     if (rank == 0) PetscCall(PetscDrawMovieSave(fname, draw->savefilecount, imext, draw->savemoviefps, mvext));
    269:     PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));
    270:   }
    271:   PetscFunctionReturn(PETSC_SUCCESS);
    272: }

    274: #if defined(PETSC_HAVE_SAWS)
    275: #include <petscviewersaws.h>
    276: /*
    277:   The PetscImageList object and functions are used to maintain a list of file images
    278:   that can be displayed by the SAWs webserver.
    279: */
    280: typedef struct _P_PetscImageList *PetscImageList;
    281: struct _P_PetscImageList {
    282:   PetscImageList next;
    283:   char          *filename;
    284:   char          *ext;
    285:   PetscInt       count;
    286: };

    288: static PetscImageList SAWs_images = NULL;

    290: static PetscErrorCode PetscImageListDestroy(void)
    291: {
    292:   PetscImageList image = SAWs_images;

    294:   PetscFunctionBegin;
    295:   while (image) {
    296:     PetscImageList next = image->next;
    297:     PetscCall(PetscFree(image->filename));
    298:     PetscCall(PetscFree(image->ext));
    299:     PetscCall(PetscFree(image));
    300:     image = next;
    301:   }
    302:   PetscFunctionReturn(PETSC_SUCCESS);
    303: }

    305: static PetscErrorCode PetscImageListAdd(const char filename[], const char ext[], PetscInt count)
    306: {
    307:   PetscImageList image, oimage = SAWs_images;
    308:   PetscBool      flg;

    310:   PetscFunctionBegin;
    311:   if (oimage) {
    312:     PetscCall(PetscStrcmp(filename, oimage->filename, &flg));
    313:     if (flg) {
    314:       oimage->count = count;
    315:       PetscFunctionReturn(PETSC_SUCCESS);
    316:     }
    317:     while (oimage->next) {
    318:       oimage = oimage->next;
    319:       PetscCall(PetscStrcmp(filename, oimage->filename, &flg));
    320:       if (flg) {
    321:         oimage->count = count;
    322:         PetscFunctionReturn(PETSC_SUCCESS);
    323:       }
    324:     }
    325:     PetscCall(PetscNew(&image));
    326:     oimage->next = image;
    327:   } else {
    328:     PetscCall(PetscRegisterFinalize(PetscImageListDestroy));
    329:     PetscCall(PetscNew(&image));
    330:     SAWs_images = image;
    331:   }
    332:   PetscCall(PetscStrallocpy(filename, &image->filename));
    333:   PetscCall(PetscStrallocpy(ext, &image->ext));
    334:   image->count = count;
    335:   PetscFunctionReturn(PETSC_SUCCESS);
    336: }

    338: static PetscErrorCode PetscDrawSave_SAWs(PetscDraw draw)
    339: {
    340:   PetscImageList image;
    341:   char           body[4096];
    342:   size_t         len = 0;

    344:   PetscFunctionBegin;
    345:   if (!draw->savefilename || !draw->saveimageext) PetscFunctionReturn(PETSC_SUCCESS);
    346:   PetscCall(PetscImageListAdd(draw->savefilename, draw->saveimageext, draw->savefilecount - 1));
    347:   image = SAWs_images;
    348:   while (image) {
    349:     const char *name = image->filename;
    350:     const char *ext  = image->ext;
    351:     if (draw->savesinglefile) {
    352:       PetscCall(PetscSNPrintf(body + len, 4086 - len, "<img src=\"%s%s\" alt=\"None\">", name, ext));
    353:     } else {
    354:       PetscCall(PetscSNPrintf(body + len, 4086 - len, "<img src=\"%s/%s_%d%s\" alt=\"None\">", name, name, image->count, ext));
    355:     }
    356:     PetscCall(PetscStrlen(body, &len));
    357:     image = image->next;
    358:   }
    359:   PetscCall(PetscStrlcat(body, "<br>\n", sizeof(body)));
    360:   if (draw->savefilecount > 0) PetscCallSAWs(SAWs_Pop_Body, ("index.html", 1));
    361:   PetscCallSAWs(SAWs_Push_Body, ("index.html", 1, body));
    362:   PetscFunctionReturn(PETSC_SUCCESS);
    363: }

    365: #endif