source: trunk/packages/vizservers/nanovis/FlowCmd.cpp @ 3935

Last change on this file since 3935 was 3935, checked in by ldelgass, 6 years ago

First pass at loading VTK vector data for flows in nanovis

  • Property svn:eol-style set to native
File size: 42.2 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright (c) 2004-2013  HUBzero Foundation, LLC
4 *
5 */
6#include <assert.h>
7#define _OPEN_SYS
8#include <fcntl.h>
9#define _XOPEN_SOURCE_EXTENDED 1
10#include <sys/uio.h>
11#include <sys/stat.h>
12#include <stdlib.h>
13#include <stddef.h>
14#include <limits.h>
15#include <stdint.h>
16#include <unistd.h>
17#include <poll.h>
18
19#include <tcl.h>
20
21#include <RpOutcome.h>
22
23#include <vrmath/Vector3f.h>
24
25#include "nvconf.h"
26
27#include "nanovisServer.h"
28#include "nanovis.h"
29#include "CmdProc.h"
30#include "Command.h"
31#include "PPMWriter.h"
32#ifdef USE_VTK
33#include "VtkDataSetReader.h"
34#endif
35#include "VtkReader.h"
36#include "FlowCmd.h"
37#include "FlowTypes.h"
38#include "Flow.h"
39#include "FlowBox.h"
40#include "FlowParticles.h"
41#include "Switch.h"
42#include "TransferFunction.h"
43#include "LIC.h"
44#include "Unirect.h"
45#include "VelocityArrowsSlice.h"
46#include "Volume.h"
47#include "Trace.h"
48
49using namespace nv;
50using namespace vrmath;
51
52static Rappture::SwitchParseProc AxisSwitchProc;
53static Rappture::SwitchCustom axisSwitch = {
54    AxisSwitchProc, NULL, 0,
55};
56
57static Rappture::SwitchParseProc ColorSwitchProc;
58static Rappture::SwitchCustom colorSwitch = {
59    ColorSwitchProc, NULL, 0,
60};
61
62static Rappture::SwitchParseProc PointSwitchProc;
63static Rappture::SwitchCustom pointSwitch = {
64    PointSwitchProc, NULL, 0,
65};
66
67static Rappture::SwitchParseProc PositionSwitchProc;
68static Rappture::SwitchCustom positionSwitch = {
69    PositionSwitchProc, NULL, 0,
70};
71
72static Rappture::SwitchParseProc TransferFunctionSwitchProc;
73static Rappture::SwitchCustom transferFunctionSwitch = {
74    TransferFunctionSwitchProc, NULL, 0,
75};
76
77Rappture::SwitchSpec Flow::_switches[] = {
78    {Rappture::SWITCH_FLOAT, "-ambient", "value",
79     offsetof(FlowValues, ambient), 0},
80    {Rappture::SWITCH_BOOLEAN, "-arrows", "boolean",
81     offsetof(FlowValues, showArrows), 0},
82    {Rappture::SWITCH_CUSTOM, "-axis", "axis",
83     offsetof(FlowValues, slicePos.axis), 0, 0, &axisSwitch},
84    {Rappture::SWITCH_FLOAT, "-diffuse", "value",
85     offsetof(FlowValues, diffuse), 0},
86    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
87     offsetof(FlowValues, isHidden), 0},
88    {Rappture::SWITCH_BOOLEAN, "-light2side", "boolean",
89     offsetof(FlowValues, twoSidedLighting), 0},
90    {Rappture::SWITCH_FLOAT, "-opacity", "value",
91     offsetof(FlowValues, opacity), 0},
92    {Rappture::SWITCH_BOOLEAN, "-outline", "boolean",
93     offsetof(FlowValues, showOutline), 0},
94    {Rappture::SWITCH_CUSTOM, "-position", "number",
95     offsetof(FlowValues, slicePos), 0, 0, &positionSwitch},
96    {Rappture::SWITCH_BOOLEAN, "-slice", "boolean",
97     offsetof(FlowValues, sliceVisible), 0},
98    {Rappture::SWITCH_FLOAT, "-specularExp", "value",
99     offsetof(FlowValues, specularExp), 0},
100    {Rappture::SWITCH_FLOAT, "-specularLevel", "value",
101     offsetof(FlowValues, specular), 0},
102    {Rappture::SWITCH_CUSTOM, "-transferfunction", "name",
103     offsetof(FlowValues, transferFunction), 0, 0, &transferFunctionSwitch},
104    {Rappture::SWITCH_BOOLEAN, "-volume", "boolean",
105     offsetof(FlowValues, showVolume), 0},
106    {Rappture::SWITCH_END}
107};
108
109Rappture::SwitchSpec FlowParticles::_switches[] = {
110    {Rappture::SWITCH_CUSTOM, "-axis", "axis",
111     offsetof(FlowParticlesValues, position.axis), 0, 0, &axisSwitch},
112    {Rappture::SWITCH_CUSTOM, "-color", "{r g b a}",
113     offsetof(FlowParticlesValues, color), 0, 0,  &colorSwitch},
114    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
115     offsetof(FlowParticlesValues, isHidden), 0},
116    {Rappture::SWITCH_CUSTOM, "-position", "number",
117     offsetof(FlowParticlesValues, position), 0, 0, &positionSwitch},
118    {Rappture::SWITCH_FLOAT, "-size", "float",
119     offsetof(FlowParticlesValues, particleSize), 0},
120    {Rappture::SWITCH_END}
121};
122
123Rappture::SwitchSpec FlowBox::_switches[] = {
124    {Rappture::SWITCH_CUSTOM, "-color", "{r g b a}",
125     offsetof(FlowBoxValues, color), 0, 0,  &colorSwitch},
126    {Rappture::SWITCH_CUSTOM, "-corner1", "{x y z}",
127     offsetof(FlowBoxValues, corner1), 0, 0, &pointSwitch},
128    {Rappture::SWITCH_CUSTOM, "-corner2", "{x y z}",
129     offsetof(FlowBoxValues, corner2), 0, 0, &pointSwitch},
130    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
131     offsetof(FlowBoxValues, isHidden), 0},
132    {Rappture::SWITCH_FLOAT, "-linewidth", "number",
133     offsetof(FlowBoxValues, lineWidth), 0},
134    {Rappture::SWITCH_END}
135};
136
137static int
138FlowDataFileOp(ClientData clientData, Tcl_Interp *interp, int objc,
139               Tcl_Obj *const *objv)
140{
141    Rappture::Outcome result;
142
143    const char *fileName;
144    fileName = Tcl_GetString(objv[3]);
145    TRACE("File: %s", fileName);
146
147    int nComponents;
148    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
149        return TCL_ERROR;
150    }
151    if ((nComponents < 1) || (nComponents > 4)) {
152        Tcl_AppendResult(interp, "bad # of components \"", 
153                         Tcl_GetString(objv[4]), "\"", (char *)NULL);
154        return TCL_ERROR;
155    }
156    Rappture::Buffer buf;
157    if (!buf.load(result, fileName)) {
158        Tcl_AppendResult(interp, "can't load data from \"", fileName, "\": ",
159                         result.remark(), (char *)NULL);
160        return TCL_ERROR;
161    }
162
163    Rappture::Unirect3d *dataPtr;
164    dataPtr = new Rappture::Unirect3d(nComponents);
165    Flow *flow = (Flow *)clientData;
166    size_t length = buf.size();
167    char *bytes = (char *)buf.bytes();
168    if ((length > 4) && (strncmp(bytes, "<DX>", 4) == 0)) {
169        if (!dataPtr->importDx(result, nComponents, length-4, bytes+4)) {
170            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
171            delete dataPtr;
172            return TCL_ERROR;
173        }
174    } else if ((length > 10) && (strncmp(bytes, "unirect3d ", 10) == 0)) {
175        if (dataPtr->parseBuffer(interp, buf) != TCL_OK) {
176            delete dataPtr;
177            return TCL_ERROR;
178        }
179    } else if ((length > 10) && (strncmp(bytes, "unirect2d ", 10) == 0)) {
180        Rappture::Unirect2d *u2dPtr;
181        u2dPtr = new Rappture::Unirect2d(nComponents);
182        if (u2dPtr->parseBuffer(interp, buf) != TCL_OK) {
183            delete u2dPtr;
184            return TCL_ERROR;
185        }
186        dataPtr->convert(u2dPtr);
187        delete u2dPtr;
188    } else {
189        TRACE("header is %.14s", buf.bytes());
190        if (!dataPtr->importDx(result, nComponents, length, bytes)) {
191            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
192            delete dataPtr;
193            return TCL_ERROR;
194        }
195    }
196    if (dataPtr->nValues() == 0) {
197        delete dataPtr;
198        Tcl_AppendResult(interp, "no data found in \"", fileName, "\"",
199                         (char *)NULL);
200        return TCL_ERROR;
201    }
202    flow->data(dataPtr);
203    Flow::updatePending = true;
204    NanoVis::eventuallyRedraw();
205    return TCL_OK;
206}
207
208/**
209 * $flow data follows nbytes nComponents
210 */
211static int
212FlowDataFollowsOp(ClientData clientData, Tcl_Interp *interp, int objc,
213                  Tcl_Obj *const *objv)
214{
215    Rappture::Outcome result;
216
217    TRACE("Enter");
218
219    int nBytes;
220    if (Tcl_GetIntFromObj(interp, objv[3], &nBytes) != TCL_OK) {
221        ERROR("Bad nBytes \"%s\"", Tcl_GetString(objv[3]));
222        return TCL_ERROR;
223    }
224    if (nBytes <= 0) {
225        Tcl_AppendResult(interp, "bad # bytes request \"", 
226                         Tcl_GetString(objv[3]), "\" for \"data follows\"", (char *)NULL);
227        ERROR("Bad nbytes %d", nBytes);
228        return TCL_ERROR;
229    }
230    int nComponents;
231    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
232        ERROR("Bad # of components \"%s\"", Tcl_GetString(objv[4]));
233        return TCL_ERROR;
234    }
235    if (nComponents <= 0) {
236        Tcl_AppendResult(interp, "bad # of components request \"", 
237                         Tcl_GetString(objv[4]), "\" for \"data follows\"", (char *)NULL);
238        ERROR("Bad # of components %d", nComponents);
239        return TCL_ERROR;
240    }
241    Rappture::Buffer buf(nBytes);
242    TRACE("Flow data loading bytes: %d components: %d", nBytes, nComponents);
243    if (GetDataStream(interp, buf, nBytes) != TCL_OK) {
244        return TCL_ERROR;
245    }
246    char *bytes = (char *)buf.bytes();
247    size_t length = buf.size();
248
249    Rappture::Unirect3d *unirect = NULL;
250    Volume *volume = NULL;
251
252    Flow *flow = (Flow *)clientData;
253    if ((length > 4) && (strncmp(bytes, "<DX>", 4) == 0)) {
254        unirect = new Rappture::Unirect3d(nComponents);
255        if (!unirect->importDx(result, nComponents, length - 4, bytes + 4)) {
256            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
257            delete unirect;
258            return TCL_ERROR;
259        }
260    } else if ((length > 10) && (strncmp(bytes, "unirect3d ", 10) == 0)) {
261        unirect = new Rappture::Unirect3d(nComponents);
262        if (unirect->parseBuffer(interp, buf) != TCL_OK) {
263            delete unirect;
264            return TCL_ERROR;
265        }
266    } else if ((length > 10) && (strncmp(bytes, "unirect2d ", 10) == 0)) {
267        unirect = new Rappture::Unirect3d(nComponents);
268        Rappture::Unirect2d *u2dPtr;
269        u2dPtr = new Rappture::Unirect2d(nComponents);
270        if (u2dPtr->parseBuffer(interp, buf) != TCL_OK) {
271            delete u2dPtr;
272            return TCL_ERROR;
273        }
274        unirect->convert(u2dPtr);
275        delete u2dPtr;
276    } else if ((length > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
277        TRACE("VTK loading...");
278        std::stringstream fdata;
279        fdata.write(bytes, length);
280        if (length <= 0) {
281            ERROR("data buffer is empty");
282            abort();
283        }
284        Rappture::Outcome context;
285#ifdef USE_VTK
286        volume = load_vtk_volume_stream(context, flow->name(), bytes, length);
287#else
288        std::stringstream fdata;
289        fdata.write(bytes, nBytes);
290        volume = load_vtk_volume_stream(context, flow->name(), fdata);
291#endif
292        if (volume == NULL) {
293            Tcl_AppendResult(interp, context.remark(), (char*)NULL);
294            return TCL_ERROR;
295        }
296    } else {
297        TRACE("header is %.14s", buf.bytes());
298        if (!unirect->importDx(result, nComponents, length, bytes)) {
299            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
300            delete unirect;
301            return TCL_ERROR;
302        }
303    }
304    if (unirect != NULL && unirect->nValues() == 0) {
305        delete unirect;
306        Tcl_AppendResult(interp, "no data found in stream", (char *)NULL);
307        return TCL_ERROR;
308    }
309#if 0
310    TRACE("nx = %d ny = %d nz = %d",
311          unirect->xNum(), unirect->yNum(), unirect->zNum());
312    TRACE("x0 = %lg y0 = %lg z0 = %lg",
313          unirect->xMin(), unirect->yMin(), unirect->zMin());
314    TRACE("lx = %lg ly = %lg lz = %lg",
315          unirect->xMax() - unirect->xMin(),
316          unirect->yMax() - unirect->yMin(),
317          unirect->zMax() - unirect->zMin());
318    TRACE("dx = %lg dy = %lg dz = %lg",
319          unirect->xNum() > 1 ? (unirect->xMax() - unirect->xMin())/(unirect->xNum()-1) : 0,
320          unirect->yNum() > 1 ? (unirect->yMax() - unirect->yMin())/(unirect->yNum()-1) : 0,
321          unirect->zNum() > 1 ? (unirect->zMax() - unirect->zMin())/(unirect->zNum()-1) : 0);
322    TRACE("magMin = %lg magMax = %lg",
323          unirect->magMin(), unirect->magMax());
324#endif
325    if (unirect != NULL) {
326        flow->data(unirect);
327    } else {
328        flow->data(volume);
329    }
330    double range[2];
331    flow->getVectorRange(range);
332    {
333        char info[1024];
334        int length = 
335            sprintf(info, "nv>data tag %s min %g max %g\n",
336                    flow->name(), range[0], range[1]);
337#ifdef USE_THREADS
338        queueResponse(info, (size_t)length, Response::VOLATILE);
339#else
340        if (SocketWrite(info, (size_t)length) < 0) {
341            return TCL_ERROR;
342        }
343#endif
344    }
345    Flow::updatePending = true;
346    NanoVis::eventuallyRedraw();
347    return TCL_OK;
348}
349
350static Rappture::CmdSpec flowDataOps[] = {
351    {"file",    2, FlowDataFileOp,    5, 5, "fileName nComponents",},
352    {"follows", 2, FlowDataFollowsOp, 5, 5, "size nComponents",},
353};
354static int nFlowDataOps = NumCmdSpecs(flowDataOps);
355
356static int
357FlowDataOp(ClientData clientData, Tcl_Interp *interp, int objc,
358           Tcl_Obj *const *objv)
359{
360    Tcl_ObjCmdProc *proc;
361
362    proc = Rappture::GetOpFromObj(interp, nFlowDataOps, flowDataOps,
363                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
364    if (proc == NULL) {
365        return TCL_ERROR;
366    }
367    return (*proc) (clientData, interp, objc, objv);
368}
369
370/**
371 * \brief Convert a Tcl_Obj representing the label of a child node into its
372 * integer node id.
373 *
374 * \param clientData Flag indicating if the node is considered before or
375 * after the insertion position.
376 * \param interp Interpreter to send results back to
377 * \param switchName Not used
378 * \param objPtr String representation
379 * \param record Structure record
380 * \param offset Not used
381 * \param flags Not used
382 *
383 * \return The return value is a standard Tcl result.
384 */
385static int
386AxisSwitchProc(ClientData clientData, Tcl_Interp *interp,
387               const char *switchName, Tcl_Obj *objPtr,
388               char *record, int offset, int flags)
389{
390    const char *string = Tcl_GetString(objPtr);
391    if (string[1] == '\0') {
392        FlowSliceAxis *axisPtr = (FlowSliceAxis *)(record + offset);
393        char c;
394        c = tolower((unsigned char)string[0]);
395        if (c == 'x') {
396            *axisPtr = AXIS_X;
397            return TCL_OK;
398        } else if (c == 'y') {
399            *axisPtr = AXIS_Y;
400            return TCL_OK;
401        } else if (c == 'z') {
402            *axisPtr = AXIS_Z;
403            return TCL_OK;
404        }
405        /*FALLTHRU*/
406    }
407    Tcl_AppendResult(interp, "bad axis \"", string,
408                     "\": should be x, y, or z", (char*)NULL);
409    return TCL_ERROR;
410}
411
412/**
413 * \brief Convert a Tcl_Obj representing the label of a list of four color
414 * components in to a RGBA color value.
415 *
416 * \param clientData Flag indicating if the node is considered before or
417 * after the insertion position.
418 * \param interp Interpreter to send results back to
419 * \param switchName Not used
420 * \param objPtr String representation
421 * \param record Structure record
422 * \param offset Not used
423 * \param flags Not used
424 *
425 * \return The return value is a standard Tcl result.
426 */
427static int
428ColorSwitchProc(ClientData clientData, Tcl_Interp *interp,
429                const char *switchName, Tcl_Obj *objPtr,
430                char *record, int offset, int flags)
431{
432    Tcl_Obj **objv;
433    int objc;
434    FlowColor *color = (FlowColor *)(record + offset);
435
436    if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) {
437        return TCL_ERROR;
438    }
439    if ((objc < 3) || (objc > 4)) {
440        Tcl_AppendResult(interp, "wrong # of elements in color definition",
441                         (char *)NULL);
442        return TCL_ERROR;
443    }
444    float values[4];
445    int i;
446    values[3] = 1.0f;
447    for (i = 0; i < objc; i++) {
448        float value;
449
450        if (GetFloatFromObj(interp, objv[i], &value) != TCL_OK) {
451            return TCL_ERROR;
452        }
453        if ((value < 0.0) || (value > 1.0)) {
454            Tcl_AppendResult(interp, "bad component value in \"",
455                             Tcl_GetString(objPtr), "\": color values must be [0..1]",
456                             (char *)NULL);
457            return TCL_ERROR;
458        }
459        values[i] = value;
460    }
461    color->r = values[0];
462    color->g = values[1];
463    color->b = values[2];
464    color->a = values[3];
465    return TCL_OK;
466}
467
468/**
469 * \brief Convert a Tcl_Obj representing the a 3-D coordinate into a point.
470 *
471 * \param clientData Flag indicating if the node is considered before or
472 * after the insertion position.
473 * \param interp Interpreter to send results back to
474 * \param switchName Not used
475 * \param objPtr String representation
476 * \param record Structure record
477 * \param offset Not used
478 * \param flags Not used
479 *
480 * \return The return value is a standard Tcl result.
481 */
482static int
483PointSwitchProc(ClientData clientData, Tcl_Interp *interp,
484                const char *switchName, Tcl_Obj *objPtr,
485                char *record, int offset, int flags)
486{
487    FlowPoint *point = (FlowPoint *)(record + offset);
488    int objc;
489    Tcl_Obj **objv;
490
491    if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) {
492        return TCL_ERROR;
493    }
494    if (objc != 3) {
495        Tcl_AppendResult(interp, "wrong # of elements for box coordinates: "
496                         " should be \"x y z\"", (char *)NULL);
497        return TCL_ERROR;
498    }
499    float values[3];
500    int i;
501    for (i = 0; i < objc; i++) {
502        float value;
503
504        if (GetFloatFromObj(interp, objv[i], &value) != TCL_OK) {
505            return TCL_ERROR;
506        }
507        values[i] = value;
508    }
509    point->x = values[0];
510    point->y = values[1];
511    point->z = values[2];
512    return TCL_OK;
513}
514
515/**
516 * \brief Convert a Tcl_Obj representing the a 3-D coordinate into a point.
517 *
518 * \param clientData Flag indicating if the node is considered before or
519 * after the insertion position.
520 * \param interp Interpreter to send results back to
521 * \param switchName Not used
522 * \param objPtr String representation
523 * \param record Structure record
524 * \param offset Not used
525 * \param flags Not used
526 *
527 * \return The return value is a standard Tcl result.
528 */
529static int
530PositionSwitchProc(ClientData clientData, Tcl_Interp *interp,
531                   const char *switchName, Tcl_Obj *objPtr,
532                   char *record, int offset, int flags)
533{
534    FlowPosition *posPtr = (FlowPosition *)(record + offset);
535    const char *string;
536    char *p;
537
538    string = Tcl_GetString(objPtr);
539    p = strrchr((char *)string, '%');
540    if (p == NULL) {
541        float value;
542
543        if (GetFloatFromObj(interp, objPtr, &value) != TCL_OK) {
544            return TCL_ERROR;
545        }
546        posPtr->value = value;
547        posPtr->flags = ABSPOS;
548    } else {
549        double value;
550
551        *p = '\0';
552        if (Tcl_GetDouble(interp, string, &value) != TCL_OK) {
553            return TCL_ERROR;
554        }
555        posPtr->value = (float)value * 0.01;
556        posPtr->flags = RELPOS;
557    }
558    return TCL_OK;
559}
560
561/**
562 * \brief Convert a Tcl_Obj representing the transfer function into a
563 *  TransferFunction pointer. 
564 *
565 * The transfer function must have been previously defined.
566 *
567 * \param clientData Flag indicating if the node is considered before or
568 * after the insertion position.
569 * \param interp Interpreter to send results back to
570 * \param switchName Not used
571 * \param objPtr String representation
572 * \param record Structure record
573 * \param offset Not used
574 * \param flags Not used
575 *
576 * \return The return value is a standard Tcl result.
577 */
578static int
579TransferFunctionSwitchProc(ClientData clientData, Tcl_Interp *interp,
580                           const char *switchName, Tcl_Obj *objPtr,
581                           char *record, int offset, int flags)
582{
583    TransferFunction **funcPtrPtr = (TransferFunction **)(record + offset);
584    TransferFunction *tf = NanoVis::getTransferFunction(Tcl_GetString(objPtr));
585    if (tf == NULL) {
586        Tcl_AppendResult(interp, "transfer function \"", Tcl_GetString(objPtr),
587                         "\" is not defined", (char*)NULL);
588        return TCL_ERROR;
589    }
590    *funcPtrPtr = tf;
591    return TCL_OK;
592}
593
594static int
595FlowConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
596                Tcl_Obj *const *objv)
597{
598    Flow *flow = (Flow *)clientData;
599
600    if (flow->parseSwitches(interp, objc - 2, objv + 2) != TCL_OK) {
601        return TCL_ERROR;
602    }
603    if (flow->configure()) {
604        Flow::updatePending = true;
605    }
606    NanoVis::eventuallyRedraw();
607    return TCL_OK;
608}
609
610static int
611FlowParticlesAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
612                   Tcl_Obj *const *objv)
613{
614    Flow *flow = (Flow *)clientData;
615    const char *particlesName = Tcl_GetString(objv[3]);
616    FlowParticles *particles = flow->createParticles(particlesName);
617    if (particles == NULL) {
618        Tcl_AppendResult(interp, "Flow particle injection plane \"",
619                         particlesName,
620                         "\" already exists or could not be created",
621                         (char*)NULL);
622        return TCL_ERROR;
623    }
624    if (particles->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
625        flow->deleteParticles(particlesName);
626        return TCL_ERROR;
627    }
628    particles->configure();
629    Flow::updatePending = true;
630    NanoVis::eventuallyRedraw();
631    Tcl_SetObjResult(interp, objv[3]);
632    return TCL_OK;
633}
634
635static int
636FlowParticlesConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
637                         Tcl_Obj *const *objv)
638{
639    Flow *flow = (Flow *)clientData;
640    const char *particlesName = Tcl_GetString(objv[3]);
641    FlowParticles *particles = flow->getParticles(particlesName);
642    if (particles == NULL) {
643        Tcl_AppendResult(interp, "Flow particle injection plane \"",
644                         particlesName, "\" not found",
645                         (char*)NULL);
646        return TCL_ERROR;
647    }
648    if (particles->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
649        return TCL_ERROR;
650    }
651    if (particles->configure()) {
652        Flow::updatePending = true;
653    }
654    NanoVis::eventuallyRedraw();
655    return TCL_OK;
656}
657
658static int
659FlowParticlesDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
660                      Tcl_Obj *const *objv)
661{
662    Flow *flow = (Flow *)clientData;
663    for (int i = 3; i < objc; i++) {
664        flow->deleteParticles(Tcl_GetString(objv[i]));
665    }
666    NanoVis::eventuallyRedraw();
667    return TCL_OK;
668}
669
670static int
671FlowParticlesNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
672                     Tcl_Obj *const *objv)
673{
674    Flow *flow = (Flow *)clientData;
675    Tcl_Obj *listObjPtr;
676    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
677    std::vector<std::string> names;
678    flow->getParticlesNames(names);
679    for (std::vector<std::string>::iterator itr = names.begin();
680         itr != names.end(); ++itr) {
681        Tcl_Obj *objPtr = Tcl_NewStringObj(itr->c_str(), -1);
682        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
683    }
684    Tcl_SetObjResult(interp, listObjPtr);
685    return TCL_OK;
686}
687
688static Rappture::CmdSpec flowParticlesOps[] = {
689    {"add",        1, FlowParticlesAddOp,        4, 0, "name ?switches?",},
690    {"configure",  1, FlowParticlesConfigureOp,  4, 0, "name ?switches?",},
691    {"delete",     1, FlowParticlesDeleteOp,     4, 0, "name ?name...?"},
692    {"names",      1, FlowParticlesNamesOp,      3, 3, ""},
693};
694
695static int nFlowParticlesOps = NumCmdSpecs(flowParticlesOps);
696
697/**
698 * \brief This procedure is invoked to process commands on behalf of the flow
699 * object.
700 *
701 * Side effects: See the user documentation.
702 *
703 * $flow particles oper $name
704 *
705 * \return A standard Tcl result.
706 */
707static int
708FlowParticlesOp(ClientData clientData, Tcl_Interp *interp, int objc, 
709                Tcl_Obj *const *objv)
710{
711    Tcl_ObjCmdProc *proc;
712    proc = Rappture::GetOpFromObj(interp, nFlowParticlesOps, flowParticlesOps, 
713                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
714    if (proc == NULL) {
715        return TCL_ERROR;
716    }
717    Flow *flow = (Flow *)clientData;
718    Tcl_Preserve(flow);
719    int result;
720    result = (*proc) (clientData, interp, objc, objv);
721    Tcl_Release(flow);
722    return result;
723}
724
725static int
726FlowBoxAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
727             Tcl_Obj *const *objv)
728{
729    Flow *flow = (Flow *)clientData;
730    const char *boxName = Tcl_GetString(objv[3]);
731    FlowBox *box = flow->createBox(boxName);
732    if (box == NULL) {
733        Tcl_AppendResult(interp, "Flow box \"", boxName, 
734                         "\" already exists or could not be created",
735                         (char*)NULL);
736        return TCL_ERROR;
737    }
738    if (box->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
739        flow->deleteBox(boxName);
740        return TCL_ERROR;
741    }
742    NanoVis::eventuallyRedraw();
743    Tcl_SetObjResult(interp, objv[3]);
744    return TCL_OK;
745}
746
747static int
748FlowBoxConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
749                   Tcl_Obj *const *objv)
750{
751    Flow *flow = (Flow *)clientData;
752    const char *boxName = Tcl_GetString(objv[3]);
753    FlowBox *box = flow->getBox(boxName);
754    if (box == NULL) {
755        Tcl_AppendResult(interp, "Flow box \"", boxName, "\" not found",
756                         (char*)NULL);
757        return TCL_ERROR;
758    }
759    if (box->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
760        return TCL_ERROR;
761    }
762    NanoVis::eventuallyRedraw();
763    return TCL_OK;
764}
765
766static int
767FlowBoxDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
768                Tcl_Obj *const *objv)
769{
770    Flow *flow = (Flow *)clientData;
771    for (int i = 3; i < objc; i++) {
772        flow->deleteBox(Tcl_GetString(objv[i]));
773    }
774    NanoVis::eventuallyRedraw();
775    return TCL_OK;
776}
777
778static int
779FlowBoxNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
780               Tcl_Obj *const *objv)
781{
782    Flow *flow = (Flow *)clientData;
783    Tcl_Obj *listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
784    std::vector<std::string> names;
785    flow->getBoxNames(names);
786    for (std::vector<std::string>::iterator itr = names.begin();
787         itr != names.end(); ++itr) {
788        Tcl_Obj *objPtr = Tcl_NewStringObj(itr->c_str(), -1);
789        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
790    }
791    Tcl_SetObjResult(interp, listObjPtr);
792    return TCL_OK;
793}
794
795static Rappture::CmdSpec flowBoxOps[] = {
796    {"add",        1, FlowBoxAddOp,        4, 0, "name ?switches?",},
797    {"configure",  1, FlowBoxConfigureOp,  4, 0, "name ?switches?",},
798    {"delete",     1, FlowBoxDeleteOp,     4, 0, "name ?name...?"},
799    {"names",      1, FlowBoxNamesOp,      3, 3, ""},
800};
801
802static int nFlowBoxOps = NumCmdSpecs(flowBoxOps);
803
804/**
805 * \brief This procedure is invoked to process commands on behalf of the flow
806 *         object.
807 *
808 * Side effects:  See the user documentation.
809 *
810 * \return A standard Tcl result.
811 */
812static int
813FlowBoxOp(ClientData clientData, Tcl_Interp *interp, int objc, 
814          Tcl_Obj *const *objv)
815{
816    Tcl_ObjCmdProc *proc;
817    proc = Rappture::GetOpFromObj(interp, nFlowBoxOps, flowBoxOps, 
818                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
819    if (proc == NULL) {
820        return TCL_ERROR;
821    }
822    Flow *flow = (Flow *)clientData;
823    Tcl_Preserve(flow);
824    int result;
825    result = (*proc) (clientData, interp, objc, objv);
826    Tcl_Release(flow);
827    return result;
828}
829
830/*
831 * CLIENT COMMAND:
832 *   $flow legend <width> <height>
833 *
834 * Clients use this to generate a legend image for the specified
835 * transfer function.  The legend image is a color gradient from 0
836 * to one, drawn in the given transfer function.  The resulting image
837 * is returned in the size <width> x <height>.
838 */
839static int
840FlowLegendOp(ClientData clientData, Tcl_Interp *interp, int objc, 
841             Tcl_Obj *const *objv)
842{
843    Flow *flow = (Flow *)clientData;
844   
845    const char *string = Tcl_GetString(objv[1]);
846    TransferFunction *tf;
847    tf = flow->getTransferFunction();
848    if (tf == NULL) {
849        Tcl_AppendResult(interp, "unknown transfer function \"", string, "\"",
850                         (char*)NULL);
851        return TCL_ERROR;
852    }
853    const char *label;
854    label = Tcl_GetString(objv[0]);
855    int w, h;
856    if ((Tcl_GetIntFromObj(interp, objv[2], &w) != TCL_OK) ||
857        (Tcl_GetIntFromObj(interp, objv[3], &h) != TCL_OK)) {
858        return TCL_ERROR;
859    }
860    if (Flow::updatePending) {
861        NanoVis::setFlowRanges();
862    }
863    NanoVis::renderLegend(tf, Flow::magMin, Flow::magMax, w, h, label);
864    return TCL_OK;
865}
866
867static Rappture::CmdSpec flowInstOps[] = {
868    {"box",         1, FlowBoxOp,        2, 0, "oper ?args?"},
869    {"configure",   1, FlowConfigureOp,  2, 0, "?switches?"},
870    {"data",        1, FlowDataOp,       2, 0, "oper ?args?"},
871    {"legend",      1, FlowLegendOp,     4, 4, "w h"},
872    {"particles",   1, FlowParticlesOp,  2, 0, "oper ?args?"}
873};
874static int nFlowInstOps = NumCmdSpecs(flowInstOps);
875
876/**
877 * \brief This procedure is invoked to process commands on behalf of the flow
878 * object.
879 *
880 * Side effects: See the user documentation.
881 *
882 * \return A standard Tcl result.
883 */
884int
885nv::FlowInstObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
886                   Tcl_Obj *const *objv)
887{
888    Tcl_ObjCmdProc *proc;
889    proc = Rappture::GetOpFromObj(interp, nFlowInstOps, flowInstOps, 
890                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
891    if (proc == NULL) {
892        return TCL_ERROR;
893    }
894    assert(CheckGL(AT));
895    Flow *flow = (Flow *)clientData;
896    Tcl_Preserve(flow);
897    int result = (*proc) (clientData, interp, objc, objv);
898    Tcl_Release(flow);
899    return result;
900}
901
902/**
903 * \brief Deletes the command associated with the flow
904 *
905 * This is called only when the command associated with the flow is destroyed.
906 */
907void
908nv::FlowInstDeleteProc(ClientData clientData)
909{
910    Flow *flow = (Flow *)clientData;
911    NanoVis::deleteFlow(flow->name());
912}
913
914static int
915FlowAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
916          Tcl_Obj *const *objv)
917{
918    const char *name = Tcl_GetString(objv[2]);
919    Tcl_CmdInfo cmdInfo;
920    if (Tcl_GetCommandInfo(interp, name, &cmdInfo)) {
921        Tcl_AppendResult(interp, "an another command \"", name, 
922                         "\" already exists.", (char *)NULL);
923        return TCL_ERROR;
924    }
925    Flow *flow = NanoVis::createFlow(interp, name);
926    if (flow == NULL) {
927        Tcl_AppendResult(interp, "Flow \"", name, "\" already exists",
928                         (char*)NULL);
929        return TCL_ERROR;
930    }
931    if (flow->parseSwitches(interp, objc - 3, objv + 3) != TCL_OK) {
932        Tcl_DeleteCommand(interp, flow->name());
933        return TCL_ERROR;
934    }
935    Tcl_SetObjResult(interp, objv[2]);
936    NanoVis::eventuallyRedraw();
937    return TCL_OK;
938}
939
940static int
941FlowDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
942             Tcl_Obj *const *objv)
943{
944    for (int i = 2; i < objc; i++) {
945        Flow *flow = NanoVis::getFlow(Tcl_GetString(objv[i]));
946        if (flow != NULL) {
947            Tcl_DeleteCommandFromToken(interp, flow->getCommandToken());
948        }
949    }
950    Flow::updatePending = true;
951    NanoVis::eventuallyRedraw();
952    return TCL_OK;
953}
954
955static int
956FlowExistsOp(ClientData clientData, Tcl_Interp *interp, int objc,
957             Tcl_Obj *const *objv)
958{
959    bool value = false;
960    Flow *flow = NanoVis::getFlow(Tcl_GetString(objv[2]));
961    if (flow != NULL) {
962        value = true;
963    }
964    Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (int)value);
965    return TCL_OK;
966}
967
968/**
969 * \brief flow goto number
970 */
971static int
972FlowGotoOp(ClientData clientData, Tcl_Interp *interp, int objc,
973           Tcl_Obj *const *objv)
974{
975    int nSteps;
976    if (Tcl_GetIntFromObj(interp, objv[2], &nSteps) != TCL_OK) {
977        return TCL_ERROR;
978    }
979    if ((nSteps < 0) || (nSteps > SHRT_MAX)) {
980        Tcl_AppendResult(interp, "flow goto: bad # of steps \"",
981                         Tcl_GetString(objv[2]), "\"", (char *)NULL);
982        return TCL_ERROR;
983    }
984    NanoVis::resetFlows();
985    if (Flow::updatePending) {
986        NanoVis::setFlowRanges();
987    }
988    for (int i = 0; i < nSteps; i++) {
989        NanoVis::licRenderer->convolve();
990        NanoVis::advectFlows();
991    }
992    NanoVis::eventuallyRedraw();
993    return TCL_OK;
994}
995
996static int
997FlowNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
998            Tcl_Obj *const *objv)
999{
1000    Tcl_Obj *listObjPtr;
1001    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
1002    for (NanoVis::FlowHashmap::iterator itr = NanoVis::flowTable.begin();
1003         itr != NanoVis::flowTable.end(); ++itr) {
1004        Flow *flow = itr->second;
1005        Tcl_Obj *objPtr = Tcl_NewStringObj(flow->name(), -1);
1006        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
1007    }
1008    Tcl_SetObjResult(interp, listObjPtr);
1009    return TCL_OK;
1010}
1011
1012static int
1013FlowNextOp(ClientData clientData, Tcl_Interp *interp, int objc,
1014           Tcl_Obj *const *objv)
1015{
1016    assert(NanoVis::licRenderer != NULL);
1017    if (Flow::updatePending) {
1018        NanoVis::setFlowRanges();
1019    }
1020    NanoVis::licRenderer->convolve();
1021    NanoVis::advectFlows();
1022    NanoVis::eventuallyRedraw();
1023    return TCL_OK;
1024}
1025
1026static int
1027FlowResetOp(ClientData clientData, Tcl_Interp *interp, int objc,
1028            Tcl_Obj *const *objv)
1029{
1030    NanoVis::resetFlows();
1031    return TCL_OK;
1032}
1033
1034#ifdef HAVE_FFMPEG
1035
1036/**
1037 * \brief Convert a Tcl_Obj representing the video format into its
1038 * integer id.
1039 *
1040 * \param clientData Not used
1041 * \param interp Interpreter to send results back to
1042 * \param switchName Not used
1043 * \param objPtr String representation
1044 * \param record Structure record
1045 * \param offset Not used
1046 * \param flags Not used
1047 *
1048 * \return The return value is a standard Tcl result.
1049 */
1050static int
1051VideoFormatSwitchProc(ClientData clientData, Tcl_Interp *interp,
1052                      const char *switchName, Tcl_Obj *objPtr,
1053                      char *record, int offset, int flags)
1054{
1055    Tcl_Obj **formatObjPtr = (Tcl_Obj **)(record + offset);
1056    Tcl_Obj *fmtObjPtr;
1057    const char *string;
1058    char c; 
1059    int length;
1060
1061    string = Tcl_GetStringFromObj(objPtr, &length);
1062    c = string[0];
1063    if ((c == 'm') && (length > 1) && 
1064        (strncmp(string, "mpeg", length) == 0)) {
1065        fmtObjPtr =  Tcl_NewStringObj("mpeg1video", 10);
1066    } else if ((c == 't') && (strncmp(string, "theora", length) == 0)) {
1067        fmtObjPtr =  Tcl_NewStringObj("theora", 6);
1068    } else if ((c == 'm') && (length > 1) &&
1069               (strncmp(string, "mov", length) == 0)) {
1070        fmtObjPtr =  Tcl_NewStringObj("mov", 3);
1071    } else {
1072        Tcl_AppendResult(interp, "bad video format \"", string,
1073                         "\": should be mpeg, theora, or mov", (char*)NULL);
1074        return TCL_ERROR;
1075    }
1076    if (*formatObjPtr != NULL) {
1077        Tcl_DecrRefCount(*formatObjPtr);
1078    }
1079    Tcl_IncrRefCount(fmtObjPtr);
1080    *formatObjPtr = fmtObjPtr;
1081    return TCL_OK;
1082}
1083
1084struct FlowVideoSwitches {
1085    float frameRate;         /**< Frame rate */
1086    int bitRate;             /**< Video bitrate */
1087    int width, height;       /**< Dimensions of video frame. */
1088    int numFrames;
1089    Tcl_Obj *formatObjPtr;
1090};
1091
1092static Rappture::SwitchParseProc VideoFormatSwitchProc;
1093static Rappture::SwitchCustom videoFormatSwitch = {
1094    VideoFormatSwitchProc, NULL, 0,
1095};
1096
1097static Rappture::SwitchSpec flowVideoSwitches[] = {
1098    {Rappture::SWITCH_INT, "-bitrate", "value",
1099     offsetof(FlowVideoSwitches, bitRate), 0},
1100    {Rappture::SWITCH_CUSTOM, "-format", "string",
1101     offsetof(FlowVideoSwitches, formatObjPtr), 0, 0, &videoFormatSwitch},
1102    {Rappture::SWITCH_FLOAT, "-framerate", "value",
1103     offsetof(FlowVideoSwitches, frameRate), 0},
1104    {Rappture::SWITCH_INT, "-height", "integer",
1105     offsetof(FlowVideoSwitches, height), 0},
1106    {Rappture::SWITCH_INT, "-numframes", "count",
1107     offsetof(FlowVideoSwitches, numFrames), 0},
1108    {Rappture::SWITCH_INT, "-width", "integer",
1109     offsetof(FlowVideoSwitches, width), 0},
1110    {Rappture::SWITCH_END}
1111};
1112
1113static bool
1114MakeImageFiles(char *tmpFileName,
1115               int width, int height, int numFrames,
1116               bool *cancelPtr)
1117{
1118    struct pollfd pollResults;
1119    pollResults.fd = fileno(nv::g_fIn);
1120    pollResults.events = POLLIN;
1121#define PENDING_TIMEOUT          10  /* milliseconds. */
1122    int timeout = PENDING_TIMEOUT;
1123
1124    int oldWidth, oldHeight;
1125    oldWidth = NanoVis::winWidth;
1126    oldHeight = NanoVis::winHeight;
1127
1128    if (width != oldWidth ||
1129        height != oldHeight) {
1130        // Resize to the requested size.
1131        NanoVis::resizeOffscreenBuffer(width, height);
1132    }
1133    NanoVis::resetFlows();
1134    *cancelPtr = false;
1135    bool result = true;
1136    size_t length = strlen(tmpFileName);
1137    for (int i = 1; i <= numFrames; i++) {
1138        if (((i & 0xF) == 0) && (poll(&pollResults, 1, timeout) > 0)) {
1139            /* If there's another command on stdin, that means the client is
1140             * trying to cancel this operation. */
1141            *cancelPtr = true;
1142            break;
1143        }
1144
1145        NanoVis::licRenderer->convolve();
1146        NanoVis::advectFlows();
1147
1148        int fboOrig;
1149        glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
1150
1151        NanoVis::bindOffscreenBuffer();
1152        NanoVis::render();
1153        NanoVis::readScreen();
1154
1155        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
1156
1157        sprintf(tmpFileName + length, "/image%d.ppm", i);
1158        result = nv::writePPMFile(tmpFileName, NanoVis::screenBuffer,
1159                                  width, height);
1160        if (!result) {
1161            break;
1162        }
1163    }
1164    if (width != oldWidth || 
1165        height != oldHeight) {
1166        NanoVis::resizeOffscreenBuffer(oldWidth, oldHeight);
1167    }
1168    tmpFileName[length] = '\0';
1169    NanoVis::resetFlows();
1170    return result;
1171}
1172
1173static int
1174MakeMovie(Tcl_Interp *interp, char *tmpFileName, const char *token,
1175          FlowVideoSwitches *switchesPtr)
1176{
1177#ifndef FFMPEG
1178#  define FFMPEG "/usr/bin/ffmpeg"
1179#endif
1180    /* Generate the movie from the frame images by exec-ing ffmpeg */
1181    /* The ffmpeg command is
1182     *   ffmpeg -f image2 -i /var/tmp/xxxxx/image%d.ppm                 \
1183     *      -b bitrate -f framerate /var/tmp/xxxxx/movie.mpeg
1184     */
1185    char cmd[BUFSIZ];
1186    sprintf(cmd, "%s -f image2 -i %s/image%%d.ppm -f %s -b %d -r %f -",
1187            FFMPEG, tmpFileName, Tcl_GetString(switchesPtr->formatObjPtr), 
1188            switchesPtr->bitRate, switchesPtr->frameRate);
1189    TRACE("Enter: %s", cmd);
1190    FILE *f;
1191    f = popen(cmd, "r");
1192    if (f == NULL) {
1193        Tcl_AppendResult(interp, "can't run ffmpeg: ", 
1194                         Tcl_PosixError(interp), (char *)NULL);
1195        return TCL_ERROR;
1196    }
1197    Rappture::Buffer data;
1198    size_t total = 0;
1199    for (;;) {
1200        ssize_t numRead;
1201        char buffer[BUFSIZ]; 
1202       
1203        numRead = fread(buffer, sizeof(unsigned char), BUFSIZ, f);
1204        total += numRead;
1205        if (numRead == 0) {             // EOF
1206            break;
1207        }
1208        if (numRead < 0) {              // Error
1209            ERROR("Can't read movie data: %s",
1210                  Tcl_PosixError(interp));
1211            Tcl_AppendResult(interp, "can't read movie data: ", 
1212                Tcl_PosixError(interp), (char *)NULL);
1213            return TCL_ERROR;
1214        }
1215        if (!data.append(buffer, numRead)) {
1216            ERROR("Can't append movie data to buffer %d bytes",
1217                  numRead);
1218            Tcl_AppendResult(interp, "can't append movie data to buffer",
1219                             (char *)NULL);
1220            return TCL_ERROR;
1221        }
1222    }
1223    if (data.size() == 0) {
1224        ERROR("ffmpeg returned 0 bytes");
1225    }
1226    // Send zero length to client so it can deal with error
1227    sprintf(cmd,"nv>image -type movie -token \"%s\" -bytes %lu\n", 
1228            token, (unsigned long)data.size());
1229    nv::sendDataToClient(cmd, data.bytes(), data.size());
1230    return TCL_OK;
1231}
1232
1233static int
1234FlowVideoOp(ClientData clientData, Tcl_Interp *interp, int objc, 
1235            Tcl_Obj *const *objv)
1236{
1237    FlowVideoSwitches switches;
1238    const char *token;
1239
1240    token = Tcl_GetString(objv[2]);
1241    switches.frameRate = 25.0f;                // Default frame rate 25 fps
1242    switches.bitRate = 6000000;                // Default video bit rate.
1243    switches.width = NanoVis::winWidth;
1244    switches.height = NanoVis::winHeight;
1245    switches.numFrames = 100;
1246    switches.formatObjPtr = Tcl_NewStringObj("mpeg1video", 10);
1247    Tcl_IncrRefCount(switches.formatObjPtr);
1248    if (Rappture::ParseSwitches(interp, flowVideoSwitches, 
1249                objc - 3, objv + 3, &switches, SWITCH_DEFAULTS) < 0) {
1250        return TCL_ERROR;
1251    }
1252    if ((switches.width < 0) || (switches.width > SHRT_MAX) || 
1253        (switches.height < 0) || (switches.height > SHRT_MAX)) {
1254        Tcl_AppendResult(interp, "bad dimensions for video", (char *)NULL);
1255        return TCL_ERROR;
1256    }
1257    if ((switches.frameRate < 0.0f) || (switches.frameRate > 30.0f)) {
1258        Tcl_AppendResult(interp, "bad frame rate.", (char *)NULL);
1259        return TCL_ERROR;
1260    }
1261    if (switches.bitRate < 0) {
1262        Tcl_AppendResult(interp, "bad bit rate.", (char *)NULL);
1263        return TCL_ERROR;
1264    }
1265    if (NanoVis::licRenderer == NULL) {
1266        Tcl_AppendResult(interp, "no lic renderer.", (char *)NULL);
1267        return TCL_ERROR;
1268    }
1269    TRACE("FLOW started");
1270
1271    char *tmpFileName;
1272    char nameTemplate[200];
1273    strcpy(nameTemplate,"/var/tmp/flowXXXXXX");
1274    tmpFileName = mkdtemp(nameTemplate);
1275    int result = TCL_OK;
1276    if (tmpFileName == NULL) {
1277        Tcl_AppendResult(interp, "can't create temporary directory \"",
1278                         nameTemplate, "\" for frame image files: ", 
1279                         Tcl_PosixError(interp), (char *)NULL);
1280        return TCL_ERROR;
1281    }
1282    size_t length = strlen(tmpFileName);
1283    bool canceled = false;
1284    if (MakeImageFiles(tmpFileName,
1285                       switches.width, switches.height, switches.numFrames,
1286                       &canceled)) {
1287        result = TCL_OK;
1288    } else {
1289        result = TCL_ERROR;
1290    }
1291    if ((result == TCL_OK) && (!canceled)) {
1292        result = MakeMovie(interp, tmpFileName, token, &switches);
1293    }
1294    for (int i = 1; i <= switches.numFrames; i++) {
1295        sprintf(tmpFileName + length, "/image%d.ppm", i);
1296        unlink(tmpFileName);
1297    }
1298    tmpFileName[length] = '\0';
1299    rmdir(tmpFileName);
1300    Rappture::FreeSwitches(flowVideoSwitches, &switches, 0);
1301    return result;
1302}
1303#else
1304/**
1305 *  Not implemented
1306 */
1307static int
1308FlowVideoOp(ClientData clientData, Tcl_Interp *interp, int objc, 
1309            Tcl_Obj *const *objv)
1310{
1311    return TCL_OK;
1312}
1313#endif /* HAVE_FFMPEG */
1314
1315static Rappture::CmdSpec flowCmdOps[] = {
1316    {"add",      1, FlowAddOp,     3, 0, "name ?option value...?",},
1317    {"delete",   1, FlowDeleteOp,  3, 0, "name ?name...?",},
1318    {"exists",   1, FlowExistsOp,  3, 3, "name",},
1319    {"goto",     1, FlowGotoOp,    3, 3, "nSteps",},
1320    {"names",    1, FlowNamesOp,   2, 2, "",},
1321    {"next",     2, FlowNextOp,    2, 2, "",},
1322    {"reset",    1, FlowResetOp,   2, 2, "",},
1323    {"video",    1, FlowVideoOp,   3, 0, "token ?switches...?",},
1324};
1325static int nFlowCmdOps = NumCmdSpecs(flowCmdOps);
1326
1327static int
1328FlowCmdProc(ClientData clientData, Tcl_Interp *interp, int objc,
1329            Tcl_Obj *const *objv)
1330{
1331    Tcl_ObjCmdProc *proc;
1332
1333    proc = Rappture::GetOpFromObj(interp, nFlowCmdOps, flowCmdOps, 
1334                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
1335    if (proc == NULL) {
1336        return TCL_ERROR;
1337    }
1338    return (*proc) (clientData, interp, objc, objv);
1339}
1340
1341/**
1342 *\brief This procedure is invoked to initialize the "flow" command.
1343 *
1344 * Side effects:
1345 *    Creates the new command and adds a new entry into a global Tcl
1346 *    associative array.
1347 */
1348void
1349nv::FlowCmdInitProc(Tcl_Interp *interp, ClientData clientData)
1350{
1351    Tcl_CreateObjCommand(interp, "flow", FlowCmdProc, clientData, NULL);
1352}
Note: See TracBrowser for help on using the repository browser.