[vtkusers] VTK Medical example

[SalaheddineSTA]

Hello, i have tried to use medical example with another dataset(DICOM images
not .Raw), but what i see is a  strange module ? please can anyone help me ?

the mhd file i use :
--------------------------
ObjectType = Image
NDims = 3
BinaryData = True
BinaryDataByteOrderMSB = False
ElementSpacing = 1 1 3
ITK_InputFilterName = MetaImageIO
DimSize = 256 256 94
ElementType = MET_USHORT
ElementDataFile = MR0000%02d 0 31 1
------------------------------

the vtk c++ code  :
------------------------------------
// testMedicalVTK.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2); // VTK was built with
vtkRenderingOpenGL2
VTK_MODULE_INIT(vtkInteractionStyle);
#define vtkRenderingCore_AUTOINIT 2(vtkRenderingOpenGL2,
vtkInteractionStyle)

#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkMarchingCubes.h>
#include <vtkMetaImageReader.h>
#include <vtkNamedColors.h>
#include <vtkOutlineFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkStripper.h>

int main()
{
        /*if (argc < 2)
        {
                cout << "Usage: " << argv[0] << " file.mhd" << endl;
                return EXIT_FAILURE;
        }*/

       
        vtkSmartPointer<vtkNamedColors> colors =
                vtkSmartPointer<vtkNamedColors>::New();

        // Set the colors.
        unsigned char skinColor[4]= { 255, 125, 64,255  };
        colors->SetColor("SkinColor", skinColor);
        unsigned char bkg[4]={ 51, 77, 102, 255  };
        colors->SetColor("BkgColor", bkg);

        // Create the renderer, the render window, and the interactor. The
renderer
        // draws into the render window, the interactor enables mouse- and
        // keyboard-based interaction with the data within the render
window.
        //
        vtkSmartPointer<vtkRenderer> aRenderer =
                vtkSmartPointer<vtkRenderer>::New();
        vtkSmartPointer<vtkRenderWindow> renWin =
                vtkSmartPointer<vtkRenderWindow>::New();
        renWin->AddRenderer(aRenderer);

        vtkSmartPointer<vtkRenderWindowInteractor> iren =
                vtkSmartPointer<vtkRenderWindowInteractor>::New();
        iren->SetRenderWindow(renWin);

        // The following reader is used to read a series of 2D slices
(images)
        // that compose the volume. The slice dimensions are set, and the
        // pixel spacing. The data Endianness must also be specified. The
reader
        // uses the FilePrefix in combination with the slice number to
construct
        // filenames using the format FilePrefix.%d. (In this case the
FilePrefix
        // is the root name of the file: quarter.)
        vtkSmartPointer<vtkMetaImageReader> reader =
                vtkSmartPointer<vtkMetaImageReader>::New();
        reader->SetFileName("C:\\Users\\usr\\Desktop\\SE000002\\img.mhd");
        // An isosurface, or contour value of 500 is known to correspond to
the
        // skin of the patient.
        // The triangle stripper is used to create triangle strips from the
        // isosurface; these render much faster on many systems.
        vtkSmartPointer<vtkMarchingCubes> skinExtractor =
                vtkSmartPointer<vtkMarchingCubes>::New();
        skinExtractor->SetInputConnection(reader->GetOutputPort());
        skinExtractor->SetValue(0, 500);

        vtkSmartPointer<vtkStripper> skinStripper =
                vtkSmartPointer<vtkStripper>::New();
        skinStripper->SetInputConnection(skinExtractor->GetOutputPort());

        vtkSmartPointer<vtkPolyDataMapper> skinMapper =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        skinMapper->SetInputConnection(skinStripper->GetOutputPort());
        skinMapper->ScalarVisibilityOff();

        vtkSmartPointer<vtkActor> skin =
                vtkSmartPointer<vtkActor>::New();
        skin->SetMapper(skinMapper);
       
skin->GetProperty()->SetDiffuseColor(colors->GetColor3d("SkinColor").GetData());
        skin->GetProperty()->SetSpecular(.3);
        skin->GetProperty()->SetSpecularPower(20);
        skin->GetProperty()->SetOpacity(1);

        // An isosurface, or contour value of 1150 is known to correspond to
the
        // bone of the patient.
        // The triangle stripper is used to create triangle strips from the
        // isosurface; these render much faster on may systems.
        vtkSmartPointer<vtkMarchingCubes> boneExtractor =
                vtkSmartPointer<vtkMarchingCubes>::New();
        boneExtractor->SetInputConnection(reader->GetOutputPort());
        boneExtractor->SetValue(0, 1150);

        vtkSmartPointer<vtkStripper> boneStripper =
                vtkSmartPointer<vtkStripper>::New();
        boneStripper->SetInputConnection(boneExtractor->GetOutputPort());

        vtkSmartPointer<vtkPolyDataMapper> boneMapper =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        boneMapper->SetInputConnection(boneStripper->GetOutputPort());
        boneMapper->ScalarVisibilityOff();

        vtkSmartPointer<vtkActor> bone =
                vtkSmartPointer<vtkActor>::New();
        bone->SetMapper(boneMapper);
       
bone->GetProperty()->SetDiffuseColor(colors->GetColor3d("Ivory").GetData());

        // An outline provides context around the data.
        //
        vtkSmartPointer<vtkOutlineFilter> outlineData =
                vtkSmartPointer<vtkOutlineFilter>::New();
        outlineData->SetInputConnection(reader->GetOutputPort());

        vtkSmartPointer<vtkPolyDataMapper> mapOutline =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        mapOutline->SetInputConnection(outlineData->GetOutputPort());

        vtkSmartPointer<vtkActor> outline =
                vtkSmartPointer<vtkActor>::New();
        outline->SetMapper(mapOutline);
       
outline->GetProperty()->SetColor(colors->GetColor3d("Yellow").GetData());

        // It is convenient to create an initial view of the data. The
FocalPoint
        // and Position form a vector direction. Later on (ResetCamera()
method)
        // this vector is used to position the camera to look at the data in
        // this direction.
        vtkSmartPointer<vtkCamera> aCamera =
vtkSmartPointer<vtkCamera>::New();
        aCamera->SetViewUp(0, 0, -1);
        aCamera->SetPosition(0, -1, 0);
        aCamera->SetFocalPoint(0, 0, 0);
        aCamera->ComputeViewPlaneNormal();
        aCamera->Azimuth(30.0);
        aCamera->Elevation(30.0);

        // Actors are added to the renderer. An initial camera view is
created.
        // The Dolly() method moves the camera towards the FocalPoint,
        // thereby enlarging the image.
        //aRenderer->AddActor(outline);
        aRenderer->AddActor(skin);
        aRenderer->AddActor(bone);
        aRenderer->SetActiveCamera(aCamera);
        aRenderer->ResetCamera();
        aCamera->Dolly(1.5);

        // Set a background color for the renderer and set the size of the
        // render window (expressed in pixels).
        aRenderer->SetBackground(colors->GetColor3d("BkgColor").GetData());
        renWin->SetSize(640, 480);

        // Note that when camera movement occurs (as it does in the Dolly()
        // method), the clipping planes often need adjusting. Clipping
planes
        // consist of two planes: near and far along the view direction. The
        // near plane clips out objects in front of the plane; the far plane
        // clips out objects behind the plane. This way only what is drawn
        // between the planes is actually rendered.
        aRenderer->ResetCameraClippingRange();

        // Initialize the event loop and then start it.
        iren->Initialize();
        iren->Start();

        return EXIT_SUCCESS;
    return 0;
}

------------------------------------------------------------------------ 



--
Sent from: http://vtk.1045678.n5.nabble.com/VTK-Users-f1224199.html