Changeset 3499 for trunk/packages


Ignore:
Timestamp:
Mar 14, 2013, 12:59:35 PM (11 years ago)
Author:
ldelgass
Message:

Add workaround for vtkAssembly bug in Cutplane (should allow using vanilla
VTK).

Location:
trunk/packages/vizservers/vtkvis
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/vtkvis/RpCutplane.cpp

    r3330 r3499  
    3636Cutplane::Cutplane() :
    3737    VtkGraphicsObject(),
     38    _pipelineInitialized(false),
    3839    _colorMap(NULL),
    3940    _colorMode(COLOR_BY_SCALAR),
    … …  
    123124           
    124125            getAssembly()->AddPart(_borderActor[i]);
    125             getAssembly()->AddPart(_actor[i]);
     126            //getAssembly()->AddPart(_actor[i]);
     127        }
     128    } else {
     129        for (int i = 0; i < 3; i++) {
     130            getAssembly()->RemovePart(_actor[i]);
    126131        }
    127132    }
    … …  
    160165            //_mapper[i]->InterpolateScalarsBeforeMappingOn();
    161166        }
    162         _cutPlane[i] = vtkSmartPointer<vtkPlane>::New();
    163         switch (i) {
    164         case 0:
    165             _cutPlane[i]->SetNormal(1, 0, 0);
    166             _cutPlane[i]->SetOrigin(bounds[0] + (bounds[1]-bounds[0])/2.,
    167                                     0,
    168                                     0);
    169             break;
    170         case 1:
    171             _cutPlane[i]->SetNormal(0, 1, 0);
    172             _cutPlane[i]->SetOrigin(0,
    173                                     bounds[2] + (bounds[3]-bounds[2])/2.,
    174                                     0);
    175             break;
    176         case 2:
    177         default:
    178             _cutPlane[i]->SetNormal(0, 0, 1);
    179             _cutPlane[i]->SetOrigin(0,
    180                                     0,
    181                                     bounds[4] + (bounds[5]-bounds[4])/2.);
    182             break;
    183         }
    184         _cutter[i] = vtkSmartPointer<vtkCutter>::New();
    185         _cutter[i]->SetCutFunction(_cutPlane[i]);
     167        if (_cutPlane[i] == NULL) {
     168            _cutPlane[i] = vtkSmartPointer<vtkPlane>::New();
     169            switch (i) {
     170            case 0:
     171                _cutPlane[i]->SetNormal(1, 0, 0);
     172                _cutPlane[i]->SetOrigin(bounds[0] + (bounds[1]-bounds[0])/2.,
     173                                        0,
     174                                        0);
     175                break;
     176            case 1:
     177                _cutPlane[i]->SetNormal(0, 1, 0);
     178                _cutPlane[i]->SetOrigin(0,
     179                                        bounds[2] + (bounds[3]-bounds[2])/2.,
     180                                        0);
     181                break;
     182            case 2:
     183            default:
     184                _cutPlane[i]->SetNormal(0, 0, 1);
     185                _cutPlane[i]->SetOrigin(0,
     186                                        0,
     187                                        bounds[4] + (bounds[5]-bounds[4])/2.);
     188                break;
     189            }
     190        }
     191        if (_cutter[i] == NULL) {
     192            _cutter[i] = vtkSmartPointer<vtkCutter>::New();
     193            _cutter[i]->SetCutFunction(_cutPlane[i]);
     194        }
    186195    }
    187196
    188197    initProp();
    189198
    190     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
    191     if (pd &&
    192         pd->GetNumberOfLines() == 0 &&
    193         pd->GetNumberOfPolys() == 0 &&
    194         pd->GetNumberOfStrips() == 0) {
    195         // DataSet is a point cloud
    196         PrincipalPlane plane;
    197         double offset;
    198         if (_dataSet->is2D(&plane, &offset)) {
    199             // DataSet is a 2D point cloud
     199    if (!_pipelineInitialized) {
     200        vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
     201        if (pd &&
     202            pd->GetNumberOfLines() == 0 &&
     203            pd->GetNumberOfPolys() == 0 &&
     204            pd->GetNumberOfStrips() == 0) {
     205            // DataSet is a point cloud
     206            PrincipalPlane plane;
     207            double offset;
     208            if (_dataSet->is2D(&plane, &offset)) {
     209                // DataSet is a 2D point cloud
    200210#ifdef MESH_POINT_CLOUDS
    201             vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    202             if (plane == PLANE_ZY) {
    203                 vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    204                 trans->RotateWXYZ(90, 0, 1, 0);
    205                 if (offset != 0.0) {
    206                     trans->Translate(-offset, 0, 0);
    207                 }
    208                 mesher->SetTransform(trans);
    209                 _actor[1]->VisibilityOff();
    210                 _actor[2]->VisibilityOff();
    211             } else if (plane == PLANE_XZ) {
    212                 vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    213                 trans->RotateWXYZ(-90, 1, 0, 0);
    214                 if (offset != 0.0) {
    215                     trans->Translate(0, -offset, 0);
    216                 }
    217                 mesher->SetTransform(trans);
    218                 _actor[0]->VisibilityOff();
    219                 _actor[2]->VisibilityOff();
    220             } else if (offset != 0.0) {
    221                 // XY with Z offset
    222                 vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    223                 trans->Translate(0, 0, -offset);
    224                 mesher->SetTransform(trans);
    225                 _actor[0]->VisibilityOff();
    226                 _actor[1]->VisibilityOff();
    227             }
     211                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
     212                if (plane == PLANE_ZY) {
     213                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     214                    trans->RotateWXYZ(90, 0, 1, 0);
     215                    if (offset != 0.0) {
     216                        trans->Translate(-offset, 0, 0);
     217                    }
     218                    mesher->SetTransform(trans);
     219                    _actor[1]->VisibilityOff();
     220                    _actor[2]->VisibilityOff();
     221                } else if (plane == PLANE_XZ) {
     222                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     223                    trans->RotateWXYZ(-90, 1, 0, 0);
     224                    if (offset != 0.0) {
     225                        trans->Translate(0, -offset, 0);
     226                    }
     227                    mesher->SetTransform(trans);
     228                    _actor[0]->VisibilityOff();
     229                    _actor[2]->VisibilityOff();
     230                } else if (offset != 0.0) {
     231                    // XY with Z offset
     232                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     233                    trans->Translate(0, 0, -offset);
     234                    mesher->SetTransform(trans);
     235                    _actor[0]->VisibilityOff();
     236                    _actor[1]->VisibilityOff();
     237                }
    228238#ifdef USE_VTK6
    229             mesher->SetInputData(pd);
     239                mesher->SetInputData(pd);
    230240#else
    231             mesher->SetInput(pd);
    232 #endif
    233             for (int i = 0; i < 3; i++) {
    234                 _mapper[i]->SetInputConnection(mesher->GetOutputPort());
    235             }
     241                mesher->SetInput(pd);
     242#endif
     243                for (int i = 0; i < 3; i++) {
     244                    _mapper[i]->SetInputConnection(mesher->GetOutputPort());
     245                }
    236246#else
    237             if (_splatter == NULL) {
    238                 _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    239             }
     247                if (_splatter == NULL) {
     248                    _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     249                }
    240250#ifdef USE_VTK6
    241             _splatter->SetInputData(pd);
     251                _splatter->SetInputData(pd);
    242252#else
    243             _splatter->SetInput(pd);
    244 #endif
    245             int dims[3];
    246             _splatter->GetSampleDimensions(dims);
    247             TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
    248             if (plane == PLANE_ZY) {
    249                 dims[0] = 3;
    250             } else if (plane == PLANE_XZ) {
    251                 dims[1] = 3;
     253                _splatter->SetInput(pd);
     254#endif
     255                int dims[3];
     256                _splatter->GetSampleDimensions(dims);
     257                TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
     258                if (plane == PLANE_ZY) {
     259                    dims[0] = 3;
     260                } else if (plane == PLANE_XZ) {
     261                    dims[1] = 3;
     262                } else {
     263                    dims[2] = 3;
     264                }
     265                _splatter->SetSampleDimensions(dims);
     266                for (int i = 0; i < 3; i++) {
     267                    _cutter[i]->SetInputConnection(_splatter->GetOutputPort());
     268                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     269                    gf->UseStripsOn();
     270                    gf->SetInputConnection(_cutter[i]->GetOutputPort());
     271                    _mapper[i]->SetInputConnection(gf->GetOutputPort());
     272                }
     273#endif
    252274            } else {
    253                 dims[2] = 3;
    254             }
    255             _splatter->SetSampleDimensions(dims);
    256             for (int i = 0; i < 3; i++) {
    257                 _cutter[i]->SetInputConnection(_splatter->GetOutputPort());
    258                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    259                 gf->UseStripsOn();
    260                 gf->SetInputConnection(_cutter[i]->GetOutputPort());
    261                 _mapper[i]->SetInputConnection(gf->GetOutputPort());
    262             }
    263 #endif
    264         } else {
    265275#ifdef MESH_POINT_CLOUDS
    266             // Data Set is a 3D point cloud
    267             // Result of Delaunay3D mesher is unstructured grid
    268             vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     276                // Data Set is a 3D point cloud
     277                // Result of Delaunay3D mesher is unstructured grid
     278                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
    269279#ifdef USE_VTK6
    270             mesher->SetInputData(pd);
     280                mesher->SetInputData(pd);
    271281#else
    272             mesher->SetInput(pd);
    273 #endif
    274             // Sample a plane within the grid bounding box
    275             for (int i = 0; i < 3; i++) {
    276                 _cutter[i]->SetInputConnection(mesher->GetOutputPort());
    277                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    278                 gf->UseStripsOn();
    279                 gf->SetInputConnection(_cutter[i]->GetOutputPort());
    280                 _mapper[i]->SetInputConnection(gf->GetOutputPort());
    281             }
     282                mesher->SetInput(pd);
     283#endif
     284                // Sample a plane within the grid bounding box
     285                for (int i = 0; i < 3; i++) {
     286                    _cutter[i]->SetInputConnection(mesher->GetOutputPort());
     287                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     288                    gf->UseStripsOn();
     289                    gf->SetInputConnection(_cutter[i]->GetOutputPort());
     290                    _mapper[i]->SetInputConnection(gf->GetOutputPort());
     291                }
    282292#else
    283             if (_splatter == NULL) {
    284                 _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    285             }
     293                if (_splatter == NULL) {
     294                    _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     295                }
    286296#ifdef USE_VTK6
    287             _splatter->SetInputData(pd);
     297                _splatter->SetInputData(pd);
    288298#else
    289             _splatter->SetInput(pd);
    290 #endif
    291             int dims[3];
    292             dims[0] = dims[1] = dims[2] = 64;
    293             TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
    294                   dims[0], dims[1], dims[2]);
    295             _splatter->SetSampleDimensions(dims);
    296             for (int i = 0; i < 3; i++) {
    297                 _cutter[i]->SetInputConnection(_splatter->GetOutputPort());
    298                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    299                 gf->UseStripsOn();
    300                 gf->SetInputConnection(_cutter[i]->GetOutputPort());
    301                 _mapper[i]->SetInputConnection(gf->GetOutputPort());
    302             }
    303 #endif
    304         }
    305     } else {
    306         // DataSet can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid, or
    307         // PolyData with cells other than points
    308         PrincipalPlane plane;
    309         double offset;
    310         if (!_dataSet->is2D(&plane, &offset)) {
    311             // Sample a plane within the grid bounding box
    312             for (int i = 0; i < 3; i++) {
    313 #ifdef USE_VTK6
    314                 _cutter[i]->SetInputData(ds);
    315 #else
    316                 _cutter[i]->SetInput(ds);
    317 #endif
    318                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    319                 gf->UseStripsOn();
    320                 gf->SetInputConnection(_cutter[i]->GetOutputPort());
    321                 _mapper[i]->SetInputConnection(gf->GetOutputPort());
     299                _splatter->SetInput(pd);
     300#endif
     301                int dims[3];
     302                dims[0] = dims[1] = dims[2] = 64;
     303                TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
     304                      dims[0], dims[1], dims[2]);
     305                _splatter->SetSampleDimensions(dims);
     306                for (int i = 0; i < 3; i++) {
     307                    _cutter[i]->SetInputConnection(_splatter->GetOutputPort());
     308                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     309                    gf->UseStripsOn();
     310                    gf->SetInputConnection(_cutter[i]->GetOutputPort());
     311                    _mapper[i]->SetInputConnection(gf->GetOutputPort());
     312                }
     313#endif
    322314            }
    323315        } else {
    324             // 2D data
    325             if (plane == PLANE_ZY) {
    326                 _actor[1]->VisibilityOff();
    327                 _actor[2]->VisibilityOff();
    328             } else if (plane == PLANE_XZ) {
    329                 _actor[0]->VisibilityOff();
    330                 _actor[2]->VisibilityOff();
    331             } else if (offset != 0.0) {
    332                 // XY with Z offset
    333                 _actor[0]->VisibilityOff();
    334                 _actor[1]->VisibilityOff();
     316            // DataSet can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid, or
     317            // PolyData with cells other than points
     318            PrincipalPlane plane;
     319            double offset;
     320            if (!_dataSet->is2D(&plane, &offset)) {
     321                // Sample a plane within the grid bounding box
     322                for (int i = 0; i < 3; i++) {
     323#ifdef USE_VTK6
     324                    _cutter[i]->SetInputData(ds);
     325#else
     326                    _cutter[i]->SetInput(ds);
     327#endif
     328                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     329                    gf->UseStripsOn();
     330                    gf->SetInputConnection(_cutter[i]->GetOutputPort());
     331                    _mapper[i]->SetInputConnection(gf->GetOutputPort());
     332                }
     333            } else {
     334                // 2D data
     335                if (plane == PLANE_ZY) {
     336                    _actor[1]->VisibilityOff();
     337                    _actor[2]->VisibilityOff();
     338                } else if (plane == PLANE_XZ) {
     339                    _actor[0]->VisibilityOff();
     340                    _actor[2]->VisibilityOff();
     341                } else if (offset != 0.0) {
     342                    // XY with Z offset
     343                    _actor[0]->VisibilityOff();
     344                    _actor[1]->VisibilityOff();
     345                }
     346                for (int i = 0; i < 3; i++) {
     347                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     348                    gf->UseStripsOn();
     349#ifdef USE_VTK6
     350                    gf->SetInputData(ds);
     351#else
     352                    gf->SetInput(ds);
     353#endif
     354                    _mapper[i]->SetInputConnection(gf->GetOutputPort());
     355                }
    335356            }
    336             for (int i = 0; i < 3; i++) {
    337                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    338                 gf->UseStripsOn();
    339 #ifdef USE_VTK6
    340                 gf->SetInputData(ds);
    341 #else
    342                 gf->SetInput(ds);
    343 #endif
    344                 _mapper[i]->SetInputConnection(gf->GetOutputPort());
    345             }
    346         }
    347     }
     357        }
     358    }
     359
     360    _pipelineInitialized = true;
    348361
    349362    for (int i = 0; i < 3; i++) {
    350         if (_mapper[i] != NULL) {
     363        if (_mapper[i] != NULL && _borderMapper[i] == NULL) {
    351364            _borderMapper[i] = vtkSmartPointer<vtkPolyDataMapper>::New();
    352365#ifdef CUTPLANE_TIGHT_OUTLINE
    … …  
    386399    if (_lut == NULL) {
    387400        setColorMap(ColorMap::getDefault());
    388     }
    389 
    390     setColorMode(_colorMode);
     401        setColorMode(_colorMode);
     402    }
    391403
    392404    for (int i = 0; i < 3; i++) {
    … …  
    398410            _borderActor[i]->SetMapper(_borderMapper[i]);
    399411            _borderMapper[i]->Update();
     412        }
     413        // Only add cutter actor to assembly if geometry was
     414        // produced, in order to prevent messing up assembly bounds
     415        double bounds[6];
     416        _actor[i]->GetBounds(bounds);
     417        if (bounds[0] <= bounds[1]) {
     418            getAssembly()->AddPart(_actor[i]);
    400419        }
    401420    }
    … …  
    450469                                     bounds[4], bounds[5]);
    451470#endif
    452         if (_mapper[0] != NULL)
    453             _mapper[0]->Update();
    454471        break;
    455472    case Y_AXIS:
    … …  
    463480                                     bounds[4], bounds[5]);
    464481#endif
    465         if (_mapper[1] != NULL)
    466             _mapper[1]->Update();
    467482        break;
    468483    case Z_AXIS:
    … …  
    476491                                     bounds[4] + (bounds[5]-bounds[4]) * ratio);
    477492#endif
    478         if (_mapper[2] != NULL)
    479             _mapper[2]->Update();
    480493        break;
    481494    default:
    … …  
    483496        return;
    484497    }
     498    update();
    485499}
    486500

  • trunk/packages/vizservers/vtkvis/RpCutplane.h

    r3330 r3499  
    9797    virtual void update();
    9898
     99    bool _pipelineInitialized;
     100
    99101    ColorMap *_colorMap;
    100102    ColorMode _colorMode;
Note: See TracChangeset for help on using the changeset viewer.