[vtkusers] THIS MAPPER IS UNSURPPORTED ON THIS PLATFORM?

Shashwath T.R. trshash at gmail.com
Mon Apr 11 07:35:12 EDT 2011


Hi,

Maybe this will help a bit:
http://www.vtk.org/pipermail/vtk-developers/2010-March/007459.html

I believe that ATI drivers (or the GLSL compiler) are buggy, and not
supported.

Shash

2011/4/11 landscapemoon <landscapemoon at 126.com>

> Hi:
>  I am a beginner.Now I do a CT series Image processing(DICOM).
> Source codes as follow:
> *************************************************************
> #if defined(_MSC_VER)
> #pragma warning ( disable : 4786 )
> #endif
> #ifdef __BORLANDC__
> #define ITK_LEAN_AND_MEAN
> #endif
> // ITK include
> #include "itkBinaryThresholdImageFilter.h"
> #include "itkCannySegmentationLevelSetImageFilter.h"
> #include "itkCastImageFilter.h"
> #include "itkConfidenceConnectedImageFilter.h"
> #include "itkCurvatureAnisotropicDiffusionImageFilter.h"
> #include "itkFastMarchingImageFilter.h"
> #include "itkGDCMImageIO.h"
> #include "itkGDCMSeriesFileNames.h"
> #include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
> #include "itkImageFileWriter.h"
> #include "itkImageSeriesReader.h"
> #include "itkImageToVTKImageFilter.h"
> #include "itkImportImageFilter.h"
> #include "itkIntensityWindowingImageFilter.h"
> #include "itkOrientedImage.h"
> #include "itkRescaleIntensityImageFilter.h"
> #include "itkSigmoidImageFilter.h"
> // VTK include
> #include "vtkActor.h"
> #include "vtkBoxWidget.h"
> #include "vtkCamera.h"
> #include "vtkCommand.h"
> #include "vtkColorTransferFunction.h"
> #include "vtkContourFilter.h"
> #include "vtkDataSetMapper.h"
> #include "vtkDICOMImageReader.h"
> #include "vtkGeometryFilter.h"
> #include "vtkGPUVolumeRayCastMapper.h"
> #include "vtkImageData.h"
> #include "vtkImageResample.h"
> #include "vtkImageViewer.h"
> #include "vtkMetaImageReader.h"
> #include "vtkPiecewiseFunction.h"
> #include "vtkPlanes.h"
> #include "vtkPolyData.h"
> #include "vtkPolyDataMapper.h"
> #include "vtkProperty.h"
> #include "vtkRenderer.h"
> #include "vtkRenderWindow.h"
> #include "vtkRenderWindowInteractor.h"
> #include "vtkVolume.h"
> #include "vtkVolumeProperty.h"
> #include "vtkXMLImageDataReader.h"
> //#include "vvITKFilterModuleBase.h"
> //#include "vtkVVPluginAPI.h"
> //#include "vvITKCannySegmentationLevelSetModule.cxx"
> #define VTI_FILETYPE 1
> #define MHA_FILETYPE 2
> class vtkBoxWidgetCallback : public vtkCommand
> {
> public:
>  static vtkBoxWidgetCallback *New()
>     {
>   return new vtkBoxWidgetCallback;
>  }
>
>  virtual void Execute(vtkObject *caller, unsigned long, void*)
>     {
>   vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
>   if (this->Mapper)
>         {
>    vtkPlanes *planes = vtkPlanes::New();
>    widget->GetPlanes(planes);
>    this->Mapper->SetClippingPlanes(planes);
>    planes->Delete();
>         }
>     }
>
>  void SetMapper(vtkGPUVolumeRayCastMapper* m)
>     {
>   this->Mapper = m;
>  }
> protected:
>  vtkBoxWidgetCallback()
>     {
>   this->Mapper = 0;
>  }
>  vtkGPUVolumeRayCastMapper *Mapper;
> };
> int main(int argc, char *argv[])
> {
>  // reader and connector
>  typedef signed short    PixelType;
>  const unsigned int      Dimension = 3;
>  typedef itk::OrientedImage< PixelType, Dimension >    ImageType;
>  typedef itk::ImageSeriesReader< ImageType >           ReaderType;
>  typedef itk::ImageToVTKImageFilter< ImageType >       ConnectType;
>
>  ReaderType::Pointer reader = ReaderType::New();
>     ConnectType::Pointer connector = ConnectType::New();
>  // set reader to DICOM
>  typedef itk::GDCMImageIO       ImageIOType;
>  ImageIOType::Pointer dicomIO = ImageIOType::New();
>  reader->SetImageIO( dicomIO );
>  typedef itk::GDCMSeriesFileNames NamesGeneratorType;
>  NamesGeneratorType::Pointer nameGenerator = NamesGeneratorType::New();
>  nameGenerator->SetUseSeriesDetails( true );
>  nameGenerator->AddSeriesRestriction( "0008|0021" );
>  nameGenerator->SetDirectory( "dicom4" );
>
> /*
>     //typedef unsigned char MaskPixelType;
>  typedef signed short MaskPixelType;
>     typedef itk::OrientedImage< MaskPixelType, Dimension > MaskImageType;
>  typedef itk::ConfidenceConnectedImageFilter< ImageType, MaskImageType >
> SegmentationFilterType;
>  SegmentationFilterType::Pointer filter = SegmentationFilterType::New();
> */
>  try
>  {
>   std::cout << std::endl << "The directory: " << std::endl;
>   std::cout << std::endl << "dicom4" << std::endl << std::endl;
>   std::cout << "Contains the following DICOM Series: ";
>   std::cout << std::endl << std::endl;
>   typedef std::vector< std::string >    SeriesIdContainer;
>   const SeriesIdContainer & seriesUID = nameGenerator->GetSeriesUIDs();
>   SeriesIdContainer::const_iterator seriesItr = seriesUID.begin();
>   SeriesIdContainer::const_iterator seriesEnd = seriesUID.end();
>
>   while( seriesItr != seriesEnd )
>   {
>    std::cout << seriesItr->c_str() << std::endl;
>    seriesItr++;
>   }
>   std::string seriesIdentifier;
>   seriesIdentifier = seriesUID.begin()->c_str();
>   std::cout << std::endl << std::endl;
>   std::cout << "Now reading series: " << std::endl << std::endl;
>   std::cout << seriesIdentifier << std::endl;
>   std::cout << std::endl << std::endl;
>   typedef std::vector< std::string >   FileNamesContainer;
>   FileNamesContainer fileNames;
>   fileNames = nameGenerator->GetFileNames( seriesIdentifier );
>   reader->SetFileNames( fileNames );
>   try
>   {
>    reader->Update();
>   }
>   catch (itk::ExceptionObject &ex)
>   {
>    std::cout << ex << std::endl;
>    return EXIT_FAILURE;
>   }
>
> ////////////////////////////////////////////////////////////
> /*   filter->SetInput( reader->GetOutput() );
>   filter->SetNumberOfIterations(0);
>   filter->SetReplaceValue(255);
>   filter->SetMultiplier(2.5);
>   ImageType::IndexType seed;
>   seed[0]=50;
>   seed[1]=50;
>   seed[2]=50;
>   filter->SetSeed(seed); */
>   //filter->Update();
>
>   // Fast Marching started...
>   typedef float RealPixelType;
>   typedef itk::OrientedImage< RealPixelType,3 >    RealImageType;
>   typedef unsigned char                            OutputPixelType;
>   typedef itk::OrientedImage< OutputPixelType, 3 > OutputImageType;
>   typedef itk::BinaryThresholdImageFilter< RealImageType, RealImageType>
> ThresholdingFilterType;
>   ThresholdingFilterType::Pointer thresholder =
> ThresholdingFilterType::New();
>   const PixelType  timeThreshold = 130;
>
>   // Threshold setting
>   thresholder->SetLowerThreshold(           0.0  );
>   thresholder->SetUpperThreshold( timeThreshold  );
>   // Value setting
>   thresholder->SetOutsideValue(  0  );
>   thresholder->SetInsideValue(  255 );
>   typedef itk::ImageFileReader< ImageType > ReaderType;
>   typedef itk::ImageFileWriter<  OutputImageType  > WriterType;
>   typedef itk::RescaleIntensityImageFilter<
>             ImageType,
>             OutputImageType >   CastFilterType;
>   typedef itk::CurvatureAnisotropicDiffusionImageFilter<
>             RealImageType,
>             RealImageType >  SmoothingFilterType;
>   SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New();
>   typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<
>             RealImageType,
>             RealImageType >  GradientFilterType;
>   typedef itk::SigmoidImageFilter<  RealImageType,
>             RealImageType >  SigmoidFilterType;
>   GradientFilterType::Pointer  gradientMagnitude =
> GradientFilterType::New();
>   SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New();
>   sigmoid->SetOutputMinimum( 0 );
>   sigmoid->SetOutputMaximum( 1 );
>   typedef  itk::FastMarchingImageFilter< RealImageType,
>                               RealImageType >    FastMarchingFilterType;
>   FastMarchingFilterType::Pointer fastMarching =
> FastMarchingFilterType::New();
>   typedef itk::CastImageFilter< ImageType,RealImageType>
> Image_to_Real_Type;
>   Image_to_Real_Type::Pointer image_to_real_Filter =
> Image_to_Real_Type::New();
>   image_to_real_Filter->SetInput(reader->GetOutput() );
>   smoothing->SetInput( image_to_real_Filter->GetOutput());
>   //real_to_image_Filter->SetInput(smoothing->GetOutput());
>   gradientMagnitude->SetInput( smoothing->GetOutput() );
>   sigmoid->SetInput( gradientMagnitude->GetOutput() );
>   fastMarching->SetInput( sigmoid->GetOutput() );
>   //fastMarching->SetInput( gradientMagnitude->GetOutput() );
>   thresholder->SetInput( fastMarching->GetOutput() );
>   smoothing->SetTimeStep( 0.0625 );
>   smoothing->SetNumberOfIterations(  3 );
>   smoothing->SetConductanceParameter( 3 );
>   const double sigma = 3;
>   gradientMagnitude->SetSigma(  sigma  );
>   sigmoid->SetAlpha( 20 );
>   sigmoid->SetBeta( 170 );
>   typedef FastMarchingFilterType::NodeContainer           NodeContainer;
>   typedef FastMarchingFilterType::NodeType                NodeType;
>   NodeContainer::Pointer seeds = NodeContainer::New();
>   ImageType::IndexType  seedPosition;
>
>   seedPosition[0] = 250;
>   seedPosition[1] = 250;
>   seedPosition[2] = 50;
>   NodeType node;
>   const double seedValue = 0.0;
>
>   node.SetValue( seedValue );
>   node.SetIndex( seedPosition );
>   seeds->Initialize();
>   seeds->InsertElement( 0, node );
>   fastMarching->SetTrialPoints(  seeds  );
>   fastMarching->SetOutputSize(
> reader->GetOutput()->GetBufferedRegion().GetSize() );
>   reader->Update();
>   fastMarching->SetStoppingValue(  100  );
>
>   typedef itk::CastImageFilter< RealImageType,ImageType>
> Real_to_Image_Type;
>   Real_to_Image_Type::Pointer real_to_image_Filter =
> Real_to_Image_Type::New();
>   real_to_image_Filter->SetInput(fastMarching->GetOutput());
>   //connector->SetInput(real_to_image_Filter->GetOutput());
>   //connector->SetInput(thresholder->GetOutput());
>   connector->SetInput(reader->GetOutput());
>   connector->Update();
>   // Fast Marching Ends.
>
> /*
>  image_to_real_Filter->SetInput( reader->GetOutput() );
>  typedef itk::FastMarchingImageFilter< RealImageType,RealImageType >
> FastMarchingFilterType;
>  FastMarchingFilterType::Pointer m_FastMarchingImageFilter          =
> FastMarchingFilterType::New();
>  m_FastMarchingImageFilter->SetSpeedConstant( 1.0 );
>  m_FastMarchingImageFilter->SetInput(image_to_real_Filter->GetOutput());
>  typedef  itk::CannySegmentationLevelSetImageFilter<itk::Image<
> RealPixelType,   3 >,itk::Image< RealPixelType,   3 >>
> CannySegmentationLevelSetFilterType;
>  CannySegmentationLevelSetFilterType::Pointer
> m_CannySegmentationLevelSetFilter  =
> CannySegmentationLevelSetFilterType::New();
>  m_CannySegmentationLevelSetFilter->SetInput(
> m_FastMarchingImageFilter->GetOutput() );
>
>  m_CannySegmentationLevelSetFilter->SetFeatureImage(  image_to_real_Filter
> ->GetOutput() );
>
>  real_to_image_Filter->SetInput(m_CannySegmentationLevelSetFilter->GetOutput());
>  connector->SetInput(real_to_image_Filter->GetOutput());
> */
>  }
>  catch (itk::ExceptionObject &ex)
>  {
>   std::cout << ex << std::endl;
>   return EXIT_FAILURE;
>     }
>  // Parse the parameters
>  int count = 1;
>  char *dirname = NULL;
>  double opacityWindow = 4096;
>  double opacityLevel = 2048;
>  int blendType = 0;
>  int clip = 0;
>  double reductionFactor = 1.0;
>  double frameRate = 10.0;
>  char *fileName = 0;
>  int fileType = 0;
>  bool independentComponents = true;
>
>  // Create the renderer, render window and interactor
>  vtkRenderer *renderer = vtkRenderer::New();
>  vtkRenderWindow *renWin = vtkRenderWindow::New();
>  renWin->AddRenderer(renderer);
>  // Connect it all. Note that funny arithmatic on the
>  // SetDesiredUpdateRate - the vtkRenderWindow divides it
>  // allocated time across all renderers, and the renderer
>  // divides it time across all props. If clip is
>  // true then there are two props
>  vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
>  iren->SetRenderWindow(renWin);
>  iren->SetDesiredUpdateRate(frameRate / (1+clip));
>  iren->GetInteractorStyle()->SetDefaultRenderer(renderer);
>  // Read the data
>    //typedef itk::VTKImageExport< MaskImageType  > ExportFilter2Type;
>  //ExportFilter2Type::Pointer itkExporter2 = ExportFilter2Type::New();
>  //itkExporter2->SetInput( filter->GetOutput() );
>     vtkDataSetMapper* geom = vtkDataSetMapper::New();
>  geom->SetInput(connector->GetOutput());
>     geom->Update();
>     vtkContourFilter * contour = vtkContourFilter::New();
>     contour->SetInput( connector->GetOutput() );
>     contour->SetValue(0, 128); // edges of a binary image with values 0,255
>  vtkPolyDataMapper * polyMapper = vtkPolyDataMapper::New();
>     vtkActor          * polyActor  = vtkActor::New();
>     //polyActor->SetMapper( polyMapper );
>
>     //polyMapper->SetInput( contour->GetOutput() );
>  //polyMapper->SetInput( geom->GetOutput() );
>     //polyMapper->ScalarVisibilityOff();
>
>  // Set the scene
>  polyActor->SetMapper( geom );
>     vtkProperty * vtkproperty = vtkProperty::New();
>     vtkproperty->SetAmbient(0.5);
>     vtkproperty->SetDiffuse(0.1);
>     vtkproperty->SetSpecular(0.5);
>     vtkproperty->SetColor(0.5,0.4,0.0);
>     vtkproperty->SetLineWidth(2.0);
>     vtkproperty->SetRepresentationToWireframe();
>  vtkproperty->SetOpacity(0.1);
>     polyActor->SetProperty( vtkproperty );
>
>     //renderer->AddActor( polyActor );
>  vtkImageData *input = 0;
>  input = connector->GetOutput();
>     vtkImageResample *resample = vtkImageResample::New();
>  if ( reductionFactor < 1.0 )
>     {
>   resample->SetInput(input);
>   resample->SetAxisMagnificationFactor(0, reductionFactor);
>   resample->SetAxisMagnificationFactor(1, reductionFactor);
>   resample->SetAxisMagnificationFactor(2, reductionFactor);
>     }
>  // Create our volume and mapper
>  vtkVolume *volume = vtkVolume::New();
>  vtkGPUVolumeRayCastMapper *mapper = vtkGPUVolumeRayCastMapper::New();
>
>  // Add a box widget if the clip option was selected
>  vtkBoxWidget *box = vtkBoxWidget::New();
>  if (clip)
>     {
>   box->SetInteractor(iren);
>   box->SetPlaceFactor(1.01);
>   if ( reductionFactor < 1.0 )
>   {
>    box->SetInput(resample->GetOutput());
>   }
>   else
>   {
>    box->SetInput(input);
>   }
>
>   box->SetDefaultRenderer(renderer);
>   box->InsideOutOn();
>   box->PlaceWidget();
>   vtkBoxWidgetCallback *callback = vtkBoxWidgetCallback::New();
>   callback->SetMapper(mapper);
>  &nbsp ;box->AddObserver(vtkCommand::InteractionEvent, callback);
>   callback->Delete();
>   box->EnabledOn();
>   box->GetSelectedFaceProperty()->SetOpacity(0.0);
>     }
>  if ( reductionFactor < 1.0 )
>     {
>   mapper->SetInputConnection( resample->GetOutputPort() );
>     }
>  else
>     {
>   mapper->SetInput(input);
>   //mapper->SetInputConnection( read->GetOutputPort() );
>     }
>
>  // Set the sample distance on the ray to be 1/2 the average spacing
>  double spacing[3];
>  if ( reductionFactor < 1.0 )
>     {
>   resample->GetOutput()->GetSpacing(spacing);
>     }
>  else
>     {
>   input->GetSpacing(spacing);
>     }
>
> //  mapper->SetSampleDistance( (spacing[0]+spacing[1]+spacing[2])/6.0 );
> //  mapper->SetMaximumImageSampleDistance(10.0);
>
>  // Create our transfer function
>  vtkColorTransferFunction *co lorFun = vtkColorTransferFunction::New();
>  vtkPiecewiseFunction *opacityFun = vtkPiecewiseFunction::New();
>
>  // Create the property and attach the transfer functions
>  vtkVolumeProperty *property = vtkVolumeProperty::New();
>  property->SetIndependentComponents(independentComponents);
>  property->SetColor( colorFun );
>  property->SetScalarOpacity( opacityFun );
>  property->SetInterpolationTypeToLinear();
>  // connect up the volume to the property and the mapper
>  volume->SetProperty( property );
>  volume->SetMapper( mapper );
>  // Depending on the blend type selected as a command line option,
>  // adjust the transfer function
>  switch ( blendType )
>     {
>     // MIP
>     // Create an opacity ramp from the window and level values.
>     // Color is white. Blending is MIP.
>     case 0:
>   colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0 );
>   opacityFun->AddSegment( opacityLevel - 0.5*opacityWindow, 0.0,
>                                 opacityLevel + 0.5*opacityWindow, 1.0 );
>   mapper->SetBlendModeToMaximumIntensity();
>   break;
>
>     // CompositeRamp
>     // Create a ramp from the window and leve l values. Use compositing
>     // without shading. Color is a ramp from black to white.
>     case 1:
>   colorFun->AddRGBSegment( opacityLevel - 0.5*opacityWindow, 0.0, 0.0, 0.0,
>
>                                  opacityLevel + 0.5*opacityWindow, 1.0,
> 1.0, 1.0 );
>   opacityFun->AddSegment( opacityLevel - 0.5*opacityWindow, 0.0,
>                                 opacityLevel + 0.5*opacityWindow, 1.0 );
>   mapper->SetBlendModeToComposite();
>   property->ShadeOff();
>   break;
>
>     // CompositeShadeRamp
> &nbs p;   // Create a ramp from the window and level values. Use
> compositing
>     // with shading. Color is white.
>     case 2:
>   colorFun->AddRGBSegment( 0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0 );
>   opacityFun->AddSegment( opacityLevel - 0.5*opacityWindow, 0.0,
>                                 opacityLevel + 0.5*opacityWindow, 1.0 );
>   mapper->SetBlendModeToComposite();
>   property->ShadeOn();
>   break;
>     // CT_Skin
>     // Use compositing and functions set to highlight skin in CT data
>     // Not for use on RGB data
>     case 3:
>   colorFun->AddRGBPoint( -3024, 0, 0, 0, 0.5, 0.0 );
>   colorFun->AddRGBPoint( -1000, .62, .36, .18, 0.5, 0.0 );
>   colorFun->AddRGBPoint( -500, .88, .60, .29, 0.33, 0.45 );
>   colorFun->AddRGBPoint( 3071, .83, .66, 1, 0.5, 0.0 );
>
>   opacityFun->AddPoint(-3024, 0, 0.5, 0.0 );
>   opacityFun->AddPoint(-1000, 0, 0.5, 0.0 );
>   opacityFun->AddPoint(-500, 1.0, 0.33, 0.45 );
>   opacityFun->AddPoint(3071, 1.0, 0.5, 0.0);
>   mapper->SetBlendModeToComposite();
>   property->ShadeOn();
>   property->SetAmbient(0.1);
>   property->SetDiffuse(0.9);
>   property->SetSpecular(0.2);
>   property->SetSpecularPower(10.0);
>   property->SetScalarOpacityUnitDistance(0.8919);
>   break;
>
>     // CT_Bone
>     // Use compositing and functions set to highlight bone in CT data
>     // Not for use on RGB data
>     case 4:
>   colorFun->AddRGBPoint( -3024, 0, 0, 0, 0.5, 0.0 );
>   colorFun->AddRGBPoint( -16, 0.73, 0.25, 0.30, 0.49, .61 );
>   colorFun->AddRGBPoint( 641, .90, .82, .56, .5, 0.0 );
>   colorFun->AddRGBPoint( 3071, 1, 1, 1, .5, 0.0 );
>
>   opacityFun->AddPoint( -3024, 0, 0.5, 0.0 );
>   opacityFun->AddPoint( -16, 0, .49, .61 );
>   opacityFun->AddPoint( 641, .72, .5, 0.0 );
>   opacityFun->AddPoint( 3071, .71, 0.5, 0.0 );
>   mapper->SetBlendModeToComposite();
>   property->ShadeOn();
>   property->SetAmbient(0.1);
>   property->SetDiffuse(0.9);
>   property->SetSpecular(0.2);
>   property->SetSpecularPower(10.0);
>   property->SetScalarOpacityUnitDistance(0.8919);
>   break;
>
>     // CT_Muscle
>     // Use compositing and functions set to highlight muscle in CT data
>     // Not for use on RGB data
>     case 5:
>   colorFun->AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0);
>   colorFun->AddRGBPoint(-155, .55, .25, .15, 0.5, .92);
>   colorFun->AddRGBPoint(217, .88, .60, .29, 0.33, 0.45);
>   colorFun->AddRGBPoint(420, 1, .94, .95, 0.5, 0.0);
>   colorFun->AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0);
>     &nb sp;
>   opacityFun->AddPoint(-3024, 0, 0.5, 0.0);
>   opacityFun->AddPoint(-155, 0, 0.5, 0.92);
>   opacityFun->AddPoint(217, .68, 0.33, 0.45);
>   opacityFun->AddPoint(420,.83, 0.5, 0.0);
>   opacityFun->AddPoint(3071, .80, 0.5, 0.0);
>   mapper->SetBlendModeToComposite();
>   property->ShadeOn();
>   property->SetAmbient(0.1);
>   property->SetDiffuse(0.9);
>   property->SetSpecular(0.2);
>   property->SetSpecularPower(10.0);
>   property->SetScalarOpacityUnitDistance(0.8919);
>   break;
>
>     // RGB_Composite
>     // Use compositing and functions set to highlight red/green/blue
> regions
>     // in RGB data. Not for use on single component data
>     case 6:
>   opacityFun->AddPoint(0, 0.0);
>   opacityFun->AddPoint(5.0, 0.0);
>   opacityFun->AddPoint(30.0, 0.05);
>   opacityFun->AddPoint(31.0, 0.0);
>   opacityFun->AddPoint(90.0, 0.0);
>   opacityFun->AddPoint(100.0, 0.3);
>   opacityFun->AddPoint(110 .0, 0.0);
>   opacityFun->AddPoint(190.0, 0.0);
>   opacityFun->AddPoint(200.0, 0.4);
>   opacityFun->AddPoint(210.0, 0.0);
>   opacityFun->AddPoint(245.0, 0.0);
>   opacityFun->AddPoint(255.0, 0.5);
>   mapper->SetBlendModeToComposite();
>   property->ShadeOff();
>   property->SetScalarOpacityUnitDistance(1.0);
>   break;
>     default:
>   vtkGenericWarningMacro("Unknown blend type.");
>   break;
>     }
>
>  // Set the default window size
>  renWin->SetSize(600,600);
>  renWin->Render();
>  if ( !mapper->IsRenderSupported(renWin, property) )
>     {
>   cout << "This mapper is unsupported on this platform" << endl;
>   exit(EXIT_FAILURE);
>     }
>
>  // Add the volume to the scene
>  renderer->AddVolume( volume );
>  renderer->ResetCamera();
>  // interact with data
>  renWin->Render();
>  iren->Start();
>  opacityFun->Delete();
>  colorFun->Delete();
>  property->Delete();
>
>  box->Delete();
>  volume->Delete();
>  mapper->Delete();
>  //reader->Delete();
>  resample->Delete();
>  renderer->Delete();
>  renWin->Delete();
>  iren->Delete();
>  contour->Delete();
>  geom->Delete();
>  polyMapper->Delete();
>  polyActor->Delete();
>  vtkproperty->Delete();
>
>  return 0;
> }
>
> ***********************************************************************************************
>
> But when I do the executable program( Navogation.exe )
>
> Picture a flash,then disappear.
>
> system prompt:<This mapper is unsurpported on this paltform>
>
> my graphics card as:ATI Radeon HD 4350
>
> Need I change my  graphics card ?
>
> thanks.
>
>
>
>
>
> _______________________________________________
> Powered by www.kitware.com
>
> Visit other Kitware open-source projects at
> http://www.kitware.com/opensource/opensource.html
>
> Please keep messages on-topic and check the VTK FAQ at:
> http://www.vtk.org/Wiki/VTK_FAQ
>
> Follow this link to subscribe/unsubscribe:
> http://www.vtk.org/mailman/listinfo/vtkusers
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.vtk.org/pipermail/vtkusers/attachments/20110411/87a8616b/attachment.htm>


More information about the vtkusers mailing list