Changeset 2506 for trunk/packages/vizservers/vtkvis

Timestamp:

Sep 10, 2011 4:23:33 PM (13 years ago)

Author:

ldelgass

Message:

Add option to send VTK file to be used for streamlines seeds. The seeds can
come from the mesh points or from filling the mesh cells with randomly
placed points. The VTK data file can be any type of dataset that has points
and cells (cells only required if using random placement within cells). Also
add option to use points of main dataset mesh.

Location:

trunk/packages/vizservers/vtkvis

Files:

• RpStreamlines.cpp (modified) (8 diffs)
• RpStreamlines.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (2 diffs)
• RpVtkRenderer.h (modified) (1 diff)
• RpVtkRendererCmd.cpp (modified) (6 diffs)
• Trace.cpp (modified) (1 diff)
• Trace.h (modified) (1 diff)
• protocol.txt (modified) (1 diff)

trunk/packages/vizservers/vtkvis/RpStreamlines.cpp

@@ -26 +26 @@
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
+#include <vtkVertexGlyphFilter.h>
 
 #include "RpStreamlines.h"
@@ -123 +124 @@
         _seedActor = vtkSmartPointer<vtkActor>::New();
         _seedActor->GetProperty()->SetColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+        _seedActor->GetProperty()->SetEdgeColor(_seedColor[0], _seedColor[1], _seedColor[2]);
         _seedActor->GetProperty()->SetLineWidth(1);
         _seedActor->GetProperty()->SetPointSize(2);
@@ -218 +220 @@
     // all cells are equal area/volume)
     int cell = rand() % numCells;
-    double bounds[6];
-    ds->GetCellBounds(cell, bounds);
-    // Note: point is inside AABB of cell, but may be outside the cell
-    getRandomPoint(pt, bounds);
+    int type = ds->GetCellType(cell);
+    if (type == VTK_VERTEX) {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 1);
+        ds->GetPoint(ptIds->GetId(0), pt);
+    } else if (type == VTK_LINE) {
+        double v[2][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 2);
+        for (int i = 0; i < 2; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        getRandomPointOnLineSegment(pt, v[0], v[1]);
+    } else if (type == VTK_TRIANGLE) {
+        double v[3][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 3);
+        for (int i = 0; i < 3; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+    } else if (type == VTK_QUAD) {
+        double v[4][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 4);
+        for (int i = 0; i < 4; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        int tri = rand() & 0x1;
+        if (tri) {
+            getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+        } else {
+            getRandomPointInTriangle(pt, v[0], v[2], v[3]);
+        }
+    } else {
+        double bounds[6];
+        ds->GetCellBounds(cell, bounds);
+        // Note: point is inside AABB of cell, but may be outside the cell
+        getRandomPoint(pt, bounds);
+    }
 }
 
@@ -286 +328 @@
         _seedMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
         _seedMapper->SetResolveCoincidentTopologyToPolygonOffset();
+        _seedMapper->ScalarVisibilityOff();
     }
 
     // Set up seed source object
-    setSeedToRandomPoints(200);
+    setSeedToFilledMesh(200);
 
     switch (_lineType) {
@@ -343 +386 @@
 
 /**
- * \brief Use randomly distributed seed points
+ * \brief Use points of the DataSet associated with this 
+ * Streamlines as seeds
+ */
+void Streamlines::setSeedToMeshPoints()
+{
+    setSeedToMeshPoints(_dataSet->getVtkDataSet());
+}
+
+/**
+ * \brief Use seed points randomly distributed within the cells 
+ * of the DataSet associated with this Streamlines
  *
  * Note: The current implementation doesn't give a uniform 
@@ -351 +404 @@
  * \param[in] numPoints Number of random seed points to generate
  */
-void Streamlines::setSeedToRandomPoints(int numPoints)
+void Streamlines::setSeedToFilledMesh(int numPoints)
+{
+    setSeedToFilledMesh(_dataSet->getVtkDataSet(), numPoints);
+}
+
+/**
+ * \brief Use points of a supplied vtkDataSet as seeds
+ *
+ * \param[in] seed vtkDataSet with points to use as seeds
+ */
+void Streamlines::setSeedToMeshPoints(vtkDataSet *seed)
+{
+    if (_streamTracer != NULL) {
+        TRACE("Seed points: %d", seed->GetNumberOfPoints());
+        vtkSmartPointer<vtkDataSet> oldSeed;
+        if (_streamTracer->GetSource() != NULL) {
+            oldSeed = _streamTracer->GetSource();
+        }
+
+        _streamTracer->SetSource(seed);
+        if (oldSeed != NULL) {
+            oldSeed->SetPipelineInformation(NULL);
+        }
+
+        if (vtkPolyData::SafeDownCast(seed) != NULL) {
+            _seedMapper->SetInput(vtkPolyData::SafeDownCast(seed));
+        } else {
+            vtkSmartPointer<vtkVertexGlyphFilter> vertFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
+            vertFilter->SetInput(seed);
+            _seedMapper->SetInputConnection(vertFilter->GetOutputPort());
+        }
+    }
+}
+
+/**
+ * \brief Use seed points randomly distributed within the cells 
+ * of a supplied vtkDataSet
+ *
+ * Note: The current implementation doesn't give a uniform 
+ * distribution of points, and points outside the mesh bounds
+ * may be generated
+ *
+ * \param[in] ds vtkDataSet containing cells
+ * \param[in] numPoints Number of random seed points to generate
+ */
+void Streamlines::setSeedToFilledMesh(vtkDataSet *ds, int numPoints)
 {
     if (_streamTracer != NULL) {
@@ -359 +457 @@
         vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
 
+        if (ds->GetNumberOfCells() < 1) {
+            ERROR("No cells in mesh");
+        }
+
         for (int i = 0; i < numPoints; i++) {
             double pt[3];
-            getRandomCellPt(pt, _dataSet->getVtkDataSet());
+            getRandomCellPt(pt, ds);
             TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
             pts->InsertNextPoint(pt);
@@ -1058 +1160 @@
     _seedColor[1] = color[1];
     _seedColor[2] = color[2];
-    if (_seedActor != NULL)
+    if (_seedActor != NULL) {
         _seedActor->GetProperty()->SetColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+        _seedActor->GetProperty()->SetEdgeColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+    }
 }
 

trunk/packages/vizservers/vtkvis/RpStreamlines.h

@@ -77 +77 @@
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
 
-    void setSeedToRandomPoints(int numPoints);
+    void setSeedToMeshPoints();
+
+    void setSeedToFilledMesh(int numPoints);
+
+    void setSeedToMeshPoints(vtkDataSet *ds);
+
+    void setSeedToFilledMesh(vtkDataSet *ds, int numPoints);
 
     void setSeedToRake(double start[3], double end[3], int numPoints);

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -6073 +6073 @@
 
 /**
+ * \brief Set the streamlines seed to points of the streamlines DataSet
+ */
+void Renderer::setStreamlinesSeedToMeshPoints(const DataSetId& id)
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setSeedToMeshPoints();
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the streamlines seed to points distributed randomly inside
+ * cells of the streamlines DataSet
+ */
+void Renderer::setStreamlinesSeedToFilledMesh(const DataSetId& id, int numPoints)
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setSeedToFilledMesh(numPoints);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the streamlines seed to points of a DataSet
+ *
+ * \param[in] id DataSet identifier
+ * \param[in] data Bytes of VTK DataSet file
+ * \param[in] nbytes Length of data array
+ *
+ * \return boolean indicating success or failure
+ */
+bool Renderer::setStreamlinesSeedToMeshPoints(const DataSetId& id,
+                                              char *data, size_t nbytes)
+{
+    vtkSmartPointer<vtkDataSetReader> reader = vtkSmartPointer<vtkDataSetReader>::New();
+    vtkSmartPointer<vtkCharArray> dataSetString = vtkSmartPointer<vtkCharArray>::New();
+
+    dataSetString->SetArray(data, nbytes, 1);
+    reader->SetInputArray(dataSetString);
+    reader->ReadFromInputStringOn();
+    reader->Update();
+
+    vtkSmartPointer<vtkDataSet> dataSet = reader->GetOutput();
+    if (dataSet == NULL) {
+        return false;
+    }
+    dataSet->SetPipelineInformation(NULL);
+
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return false;
+    }
+
+    do {
+        itr->second->setSeedToMeshPoints(dataSet);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+    return true;
+}
+
+/**
  * \brief Set the streamlines seed to points distributed randomly inside
  * cells of DataSet
- */
-void Renderer::setStreamlinesSeedToRandomPoints(const DataSetId& id, int numPoints)
-{
+ *
+ * \param[in] id DataSet identifier
+ * \param[in] data Bytes of VTK DataSet file
+ * \param[in] nbytes Length of data array
+ * \param[in] numPoints Number of random seed points to generate
+ *
+ * \return boolean indicating success or failure
+ */
+bool Renderer::setStreamlinesSeedToFilledMesh(const DataSetId& id,
+                                              char *data, size_t nbytes,
+                                              int numPoints)
+{
+    vtkSmartPointer<vtkDataSetReader> reader = vtkSmartPointer<vtkDataSetReader>::New();
+    vtkSmartPointer<vtkCharArray> dataSetString = vtkSmartPointer<vtkCharArray>::New();
+
+    dataSetString->SetArray(data, nbytes, 1);
+    reader->SetInputArray(dataSetString);
+    reader->ReadFromInputStringOn();
+    reader->Update();
+
+    vtkSmartPointer<vtkDataSet> dataSet = reader->GetOutput();
+    if (dataSet == NULL) {
+        return false;
+    }
+    dataSet->SetPipelineInformation(NULL);
+
     StreamlinesHashmap::iterator itr;
 
@@ -6090 +6217 @@
     if (itr == _streamlines.end()) {
         ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setSeedToRandomPoints(numPoints);
+        return false;
+    }
+
+    do {
+        itr->second->setSeedToFilledMesh(dataSet, numPoints);
     } while (doAll && ++itr != _streamlines.end());
 
     _needsRedraw = true;
+    return true;
 }
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -611 +611 @@
     void setStreamlinesVisibility(const DataSetId& id, bool state);
 
-    void setStreamlinesSeedToRandomPoints(const DataSetId& id, int numPoints);
+    void setStreamlinesSeedToMeshPoints(const DataSetId& id);
+
+    void setStreamlinesSeedToFilledMesh(const DataSetId& id, int numPoints);
+
+    bool setStreamlinesSeedToMeshPoints(const DataSetId& id,
+                                        char *data, size_t nbytes);
+
+    bool setStreamlinesSeedToFilledMesh(const DataSetId& id,
+                                        char *data, size_t nbytes,
+                                        int numPoints);
 
     void setStreamlinesSeedToRake(const DataSetId& id,

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -40 +40 @@
     }
     return bytesWritten;
+}
+
+static size_t
+SocketRead(void *bytes, size_t len)
+{
+#ifdef notdef
+    size_t ofs = 0;
+    ssize_t bytesRead = 0;
+    while ((bytesRead = read(g_fdIn, bytes + ofs, len - ofs)) > 0) {
+        ofs += bytesRead;
+        if (ofs == len)
+            break;
+    }
+    TRACE("bytesRead: %lu", ofs);
+    return ofs;
+#else
+    size_t bytesRead = fread(bytes, 1, len, g_fIn);
+    TRACE("bytesRead: %lu", bytesRead);
+    return bytesRead;
+#endif
 }
 
@@ -1302 +1322 @@
     }
     char *data = (char *)malloc(nbytes);
-#ifdef notdef
-    size_t ofs = 0;
-    ssize_t bytesRead = 0;
-    while ((bytesRead = read(g_fdIn, data + ofs, nbytes - ofs)) > 0) {
-        ofs += bytesRead;
-        if (ofs == nbytes)
-            break;
-    }
-    TRACE("bytesRead: %d", ofs);
+    size_t bytesRead = SocketRead(data, nbytes);
     if (bytesRead < 0) {
         free(data);
         return TCL_ERROR;
     }
-#else
-    size_t bytesRead = fread(data, 1, nbytes, g_fIn);
-    TRACE("bytesRead: %d", bytesRead);
-    if (bytesRead < (size_t)nbytes) {
-        free(data);
-        return TCL_ERROR;
-    }
-#endif
     g_renderer->addDataSet(name);
     g_renderer->setData(name, data, nbytes);
@@ -4318 +4322 @@
 
 static int
+StreamlinesSeedFilledMeshOp(ClientData clientData, Tcl_Interp *interp,
+                            int objc, Tcl_Obj *const *objv)
+{
+    int numPoints = 0;
+    if (Tcl_GetIntFromObj(interp, objv[3], &numPoints) != TCL_OK ||
+        numPoints < 1) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[4]);
+    char c = string[0];
+    if ((c != 'd') || (strcmp(string, "data") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be data", (char*)NULL);
+        return TCL_ERROR;
+    }
+    string = Tcl_GetString(objv[5]);
+    c = string[0];
+    if ((c != 'f') || (strcmp(string, "follows") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be follows", (char*)NULL);
+        return TCL_ERROR;
+    }
+    int nbytes = 0;
+    if (Tcl_GetIntFromObj(interp, objv[6], &nbytes) != TCL_OK ||
+        nbytes < 0) {
+        return TCL_ERROR;
+    }
+    char *data = (char *)malloc(nbytes);
+    size_t bytesRead = SocketRead(data, nbytes);
+    if (bytesRead < 0) {
+        free(data);
+        return TCL_ERROR;
+    }
+    if (objc == 8) {
+        const char *name = Tcl_GetString(objv[7]);
+        if (!g_renderer->setStreamlinesSeedToFilledMesh(name, data, nbytes,
+                                                        numPoints)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setStreamlinesSeedToFilledMesh("all", data, nbytes,
+                                                        numPoints)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    free(data);
+    return TCL_OK;
+}
+
+static int
+StreamlinesSeedMeshPointsOp(ClientData clientData, Tcl_Interp *interp,
+                            int objc, Tcl_Obj *const *objv)
+{
+    const char *string = Tcl_GetString(objv[3]);
+    char c = string[0];
+    if ((c != 'd') || (strcmp(string, "data") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be data", (char*)NULL);
+        return TCL_ERROR;
+    }
+    string = Tcl_GetString(objv[4]);
+    c = string[0];
+    if ((c != 'f') || (strcmp(string, "follows") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be follows", (char*)NULL);
+        return TCL_ERROR;
+    }
+    int nbytes = 0;
+    if (Tcl_GetIntFromObj(interp, objv[5], &nbytes) != TCL_OK ||
+        nbytes < 0) {
+        return TCL_ERROR;
+    }
+    char *data = (char *)malloc(nbytes);
+    size_t bytesRead = SocketRead(data, nbytes);
+    if (bytesRead < 0) {
+        free(data);
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        if (!g_renderer->setStreamlinesSeedToMeshPoints(name, data, nbytes)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setStreamlinesSeedToMeshPoints("all", data, nbytes)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    free(data);
+    return TCL_OK;
+}
+
+static int
+StreamlinesSeedPointsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                        Tcl_Obj *const *objv)
+{
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setStreamlinesSeedToMeshPoints(name);
+    } else {
+        g_renderer->setStreamlinesSeedToMeshPoints("all");
+    }
+    return TCL_OK;
+}
+
+static int
 StreamlinesSeedPolygonOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                          Tcl_Obj *const *objv)
@@ -4430 +4548 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setStreamlinesSeedToRandomPoints(name, numPoints);
-    } else {
-        g_renderer->setStreamlinesSeedToRandomPoints("all", numPoints);
+        g_renderer->setStreamlinesSeedToFilledMesh(name, numPoints);
+    } else {
+        g_renderer->setStreamlinesSeedToFilledMesh("all", numPoints);
     }
     return TCL_OK;
@@ -4457 +4575 @@
     {"color",   1, StreamlinesSeedColorOp, 6, 7, "r g b ?dataSetName?"},
     {"disk",    1, StreamlinesSeedDiskOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ radius innerRadius numPoints ?dataSetName?"},
-    {"fpoly",   1, StreamlinesSeedFilledPolygonOp, 13, 14, "centerX centerY centerZ normalX normalY normalZ angle radius numSides numPoints ?dataSetName?"},
-    {"polygon", 1, StreamlinesSeedPolygonOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ angle radius numSides ?dataSetName?"},
+    {"fmesh",   2, StreamlinesSeedFilledMeshOp, 7, 8, "numPoints data follows nbytes ?dataSetName?"},
+    {"fpoly",   2, StreamlinesSeedFilledPolygonOp, 13, 14, "centerX centerY centerZ normalX normalY normalZ angle radius numSides numPoints ?dataSetName?"},
+    {"mesh",    1, StreamlinesSeedMeshPointsOp, 6, 7, "data follows nbytes ?dataSetName?"},
+    {"points",  3, StreamlinesSeedPointsOp, 3, 4, "?dataSetName?"},
+    {"polygon", 3, StreamlinesSeedPolygonOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ angle radius numSides ?dataSetName?"},
     {"rake",    3, StreamlinesSeedRakeOp, 10, 11, "startX startY startZ endX endY endZ numPoints ?dataSetName?"},
     {"random",  3, StreamlinesSeedRandomOp, 4, 5, "numPoints ?dataSetName?"},
@@ -4534 +4655 @@
     {"ribbons",   1, StreamlinesRibbonsOp, 4, 5, "width angle ?dataSetName?"},
     {"scale",     2, StreamlinesScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
-    {"seed",      2, StreamlinesSeedOp, 4, 14, "op params... ?dataSetName?"},
+    {"seed",      2, StreamlinesSeedOp, 3, 14, "op params... ?dataSetName?"},
     {"tubes",     1, StreamlinesTubesOp, 4, 5, "numSides radius ?dataSetName?"},
     {"visible",   1, StreamlinesVisibleOp, 3, 4, "bool ?dataSetName?"}

trunk/packages/vizservers/vtkvis/Trace.cpp

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 

trunk/packages/vizservers/vtkvis/Trace.h

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -306 +306 @@
             Create a disk seed area with optional hole, filled with randomly 
             placed points
+streamlines seed fmesh <numPoints> data follows <nbytes> <?datasetName?>
+            Fill a mesh supplied as a VTK data file with randomly placed points
 streamlines seed fpoly <centerX> <centerY> <centerZ> <normalX> <normalY> <normalZ> <angle> <radius> <numSides> <numPoints> <?dataSetName?>
             Create a regular n-sided polygonal seed area filled with randomly 
             placed points
+streamlines seed mesh data follows <nbytes> <?datasetName?>
+            Use points of a mesh supplied as a VTK data file
+streamlines seed points <?datasetName?>
+            Use points of the streamlines' dataset mesh
 streamlines seed polygon <centerX> <centerY> <centerZ> <normalX> <normalY> <normalZ> <angle> <radius> <numSides> <?dataSetName?>
             Create seed points from vertices of a regular n-sided polygon
 streamlines seed rake <startX> <startY> <startZ> <endX> <endY> <endZ> <numPoints> <?datasetName?>
 streamlines seed random <numPoints> <?datasetName?>
+            Fill the streamlines' dataset mesh with randomly placed points
 streamlines seed visible <bool> <?datasetName?>
 streamlines tubes <numSides> <radius> <?datasetName?>