[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);
>   ;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