Example #1
0
    // Does not work with ActiViz.NET-5.4.0.455-Linux-x86_64-Personal

/*
 * static void ConnectSWIGToActiviz(Kitware.VTK.vtkImageExport imgin, Kitware.VTK.vtkImageImport imgout)
 *  {
 *  imgout.SetUpdateInformationCallback(imgin.GetUpdateInformationCallback());
 *  imgout.SetPipelineModifiedCallback(imgin.GetPipelineModifiedCallback());
 *  imgout.SetWholeExtentCallback(imgin.GetWholeExtentCallback());
 *  imgout.SetSpacingCallback(imgin.GetSpacingCallback());
 *  imgout.SetOriginCallback(imgin.GetOriginCallback());
 *  imgout.SetScalarTypeCallback(imgin.GetScalarTypeCallback());
 *  imgout.SetNumberOfComponentsCallback(imgin.GetNumberOfComponentsCallback());
 *  imgout.SetPropagateUpdateExtentCallback(imgin.GetPropagateUpdateExtentCallback());
 *  imgout.SetUpdateDataCallback(imgin.GetUpdateDataCallback());
 *  imgout.SetDataExtentCallback(imgin.GetDataExtentCallback());
 *  imgout.SetBufferPointerCallback(imgin.GetBufferPointerCallback());
 *  imgout.SetCallbackUserData(imgin.GetCallbackUserData());
 *  }
 */

    static Kitware.VTK.vtkImageData ConnectSWIGToActiviz(vtkgdcm.vtkImageData imgin)
    {
        HandleRef rawCppThis = imgin.GetCppThis();

        Kitware.VTK.vtkImageData imgout = new Kitware.VTK.vtkImageData(rawCppThis.Handle, false, false);
        return(imgout);
    }
Example #2
0
    static vtkgdcm.vtkImageData ConnectActivizToSWIG(Kitware.VTK.vtkImageData imgin)
    {
        HandleRef rawCppThis = imgin.GetCppThis();

        vtkgdcm.vtkImageData imgout = new vtkgdcm.vtkImageData(rawCppThis);
        return(imgout);
    }
Example #3
0
        public static vtkImageData FromImage(Image img, int numberOfScalarComponents)
        {
            Bitmap       bitmap       = new Bitmap(img);
            vtkImageData vtkImageData = vtkImageData.New();

            vtkImageData.SetScalarTypeToUnsignedChar();
            vtkImageData.SetNumberOfScalarComponents(numberOfScalarComponents);
            vtkImageData.SetDimensions(img.Width, img.Height, 1);
            vtkImageData.AllocateScalars();
            byte[] array = new byte[img.Width * img.Height * vtkImageData.GetNumberOfScalarComponents()];
            int    num   = 0;

            for (int i = img.Height - 1; i >= 0; i--)
            {
                for (int j = 0; j < img.Width; j++)
                {
                    array[num++] = bitmap.GetPixel(j, i).R;
                    array[num++] = bitmap.GetPixel(j, i).G;
                    array[num++] = bitmap.GetPixel(j, i).B;
                    if (numberOfScalarComponents > 3)
                    {
                        array[num++] = bitmap.GetPixel(j, i).A;
                    }
                }
            }
            Marshal.Copy(array, 0, vtkImageData.GetScalarPointer(), array.Length);
            return(vtkImageData);
        }
Example #4
0
        public new vtkImageData NewInstance()
        {
            vtkImageData result      = null;
            uint         mteStatus   = 0u;
            uint         mteIndex    = 4294967295u;
            uint         rawRefCount = 0u;
            IntPtr       intPtr      = vtkImageData.vtkImageData_NewInstance_75(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                result = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
            }
            return(result);
        }
Example #5
0
    public static int Main(string[] args)
    {
        string filename    = args[0];
        string outfilename = args[1];

        // Step 1. Test SWIG -> Activiz
        vtkGDCMImageReader reader = vtkGDCMImageReader.New();

        reader.SetFileName(filename);
        //reader.Update(); // DO NOT call Update to check pipeline execution

        Kitware.VTK.vtkImageData imgout = ConnectSWIGToActiviz(reader.GetOutput());

        System.Console.WriteLine(imgout.ToString()); // not initialized as expected

        vtkPNGWriter writer = new vtkPNGWriter();

        writer.SetInput(imgout);
        writer.SetFileName(outfilename);
        writer.Write();

        // Step 2. Test Activiz -> SWIG
        vtkPNGReader bmpreader = new vtkPNGReader();

        bmpreader.SetFileName(outfilename);
        //bmpreader.Update(); // DO NOT update to check pipeline execution

        System.Console.WriteLine(bmpreader.GetOutput().ToString()); // not initialized as expected

        vtkgdcm.vtkImageData imgout2 = ConnectActivizToSWIG(bmpreader.GetOutput());

        System.Console.WriteLine(imgout2.ToString()); // not initialized as expected


        Kitware.VTK.vtkMedicalImageProperties prop = new Kitware.VTK.vtkMedicalImageProperties();
        prop.SetModality("MR");

        string             outfilename2 = args[2];
        vtkGDCMImageWriter writer2      = vtkGDCMImageWriter.New();

        writer2.SetMedicalImageProperties(prop.CastToActiviz());
        writer2.SetFileName(outfilename2);
        writer2.SetInput(imgout2);
        writer2.Write();

        return(0);
    }
Example #6
0
		public vtkImageData GetImage()
		{
			vtkImageData vtkImageData = null;
			uint mteStatus = 0u;
			uint mteIndex = 4294967295u;
			uint rawRefCount = 0u;
			IntPtr intPtr = vtkGeoImageNode.vtkGeoImageNode_GetImage_05(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);
			if (IntPtr.Zero != intPtr)
			{
				bool flag;
				vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
				if (flag)
				{
					vtkImageData.Register(null);
				}
			}
			return vtkImageData;
		}
Example #7
0
        public vtkImageData GetBlankingInput()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkBlankStructuredGridWithImage.vtkBlankStructuredGridWithImage_GetBlankingInput_01(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #8
0
        public new static vtkImageData SafeDownCast(vtkObjectBase o)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkImageData.vtkImageData_SafeDownCast_77((o == null) ? default(HandleRef) : o.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #9
0
        public virtual vtkImageData GetImageData()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkTerrainContourLineInterpolator.vtkTerrainContourLineInterpolator_GetImageData_01(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public vtkImageData GetOutput(int arg0)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkImageAlgorithm.vtkImageAlgorithm_GetOutput_07(base.GetCppThis(), arg0, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #11
0
        public vtkImageData GetSource()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkProjectedTerrainPath.vtkProjectedTerrainPath_GetSource_11(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public virtual vtkImageData GetInformationInput()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkImageStencilSource.vtkImageStencilSource_GetInformationInput_01(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public override vtkImageData GetImage(int ImageNumber)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkVolume16Reader.vtkVolume16Reader_GetImage_07(base.GetCppThis(), ImageNumber, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public vtkImageData GetButtonTexture(int i)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkTexturedButtonRepresentation.vtkTexturedButtonRepresentation_GetButtonTexture_08(base.GetCppThis(), i, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #15
0
        public new vtkImageData GetInput(int port)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkStructuredPointsWriter.vtkStructuredPointsWriter_GetInput_02(base.GetCppThis(), port, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #16
0
        public new static vtkImageData GetData(vtkInformationVector v, int i)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkImageData.vtkImageData_GetData_32((v == null) ? default(HandleRef) : v.GetCppThis(), i, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #17
0
        public vtkImageData GetOutputHistogramImage(int idx)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkPairwiseExtractHistogram2D.vtkPairwiseExtractHistogram2D_GetOutputHistogramImage_12(base.GetCppThis(), idx, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public virtual vtkImageData GetOriginalSource()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkBranchExtentTranslator.vtkBranchExtentTranslator_GetOriginalSource_03(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #19
0
        public virtual vtkImageData NewImageDataCopy()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkUniformGrid.vtkUniformGrid_NewImageDataCopy_27(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #20
0
        public vtkImageData GetInput()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkImageMultipleInputFilter.vtkImageMultipleInputFilter_GetInput_06(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #21
0
        public vtkImageData GetEntryIcon(int i)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkLegendBoxActor.vtkLegendBoxActor_GetEntryIcon_15(base.GetCppThis(), i, ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
        public vtkImageData GetBalloonImage(vtkProp prop)
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkBalloonWidget.vtkBalloonWidget_GetBalloonImage_04(base.GetCppThis(), (prop == null) ? default(HandleRef) : prop.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #23
0
        public vtkGeoAlignedImageRepresentation AddDefaultImageRepresentation(vtkImageData image)
        {
            vtkGeoAlignedImageRepresentation vtkGeoAlignedImageRepresentation = null;
            uint   mteStatus   = 0u;
            uint   mteIndex    = 4294967295u;
            uint   rawRefCount = 0u;
            IntPtr intPtr      = vtkGeoView.vtkGeoView_AddDefaultImageRepresentation_01(base.GetCppThis(), (image == null) ? default(HandleRef) : image.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkGeoAlignedImageRepresentation = (vtkGeoAlignedImageRepresentation)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkGeoAlignedImageRepresentation.Register(null);
                }
            }
            return(vtkGeoAlignedImageRepresentation);
        }
Example #24
0
        public virtual vtkImageData GetDisplacementGrid()
        {
            vtkImageData vtkImageData = null;
            uint         mteStatus    = 0u;
            uint         mteIndex     = 4294967295u;
            uint         rawRefCount  = 0u;
            IntPtr       intPtr       = vtkGridTransform.vtkGridTransform_GetDisplacementGrid_01(base.GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);

            if (IntPtr.Zero != intPtr)
            {
                bool flag;
                vtkImageData = (vtkImageData)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, true, out flag);
                if (flag)
                {
                    vtkImageData.Register(null);
                }
            }
            return(vtkImageData);
        }
Example #25
0
 public virtual void AddInput(vtkImageData input)
 {
     vtkImageMultipleInputFilter.vtkImageMultipleInputFilter_AddInput_01(base.GetCppThis(), (input == null) ? default(HandleRef) : input.GetCppThis());
 }
Example #26
0
 public virtual void SetInput(int num, vtkImageData input)
 {
     vtkImageMultipleInputFilter.vtkImageMultipleInputFilter_SetInput_16(base.GetCppThis(), num, (input == null) ? default(HandleRef) : input.GetCppThis());
 }
Example #27
0
 public void SetEntryIcon(int i, vtkImageData icon)
 {
     vtkLegendBoxActor.vtkLegendBoxActor_SetEntryIcon_50(base.GetCppThis(), i, (icon == null) ? default(HandleRef) : icon.GetCppThis());
 }
Example #28
0
 public void SetEntry(int i, vtkPolyData symbol, vtkImageData icon, string arg3, IntPtr color)
 {
     vtkLegendBoxActor.vtkLegendBoxActor_SetEntry_47(base.GetCppThis(), i, (symbol == null) ? default(HandleRef) : symbol.GetCppThis(), (icon == null) ? default(HandleRef) : icon.GetCppThis(), arg3, color);
 }
Example #29
0
 public void SetEntry(int i, vtkImageData symbol, string arg2, IntPtr color)
 {
     vtkLegendBoxActor.vtkLegendBoxActor_SetEntry_46(base.GetCppThis(), i, (symbol == null) ? default(HandleRef) : symbol.GetCppThis(), arg2, color);
 }
 public void SetInput(vtkImageData input)
 {
     vtkStructuredPointsToUnstructuredGridFilter.vtkStructuredPointsToUnstructuredGridFilter_SetInput_06(base.GetCppThis(), (input == null) ? default(HandleRef) : input.GetCppThis());
 }
Example #31
0
 // Does not work with ActiViz.NET-5.4.0.455-Linux-x86_64-Personal
 /*
   static void ConnectSWIGToActiviz(Kitware.VTK.vtkImageExport imgin, Kitware.VTK.vtkImageImport imgout)
 {
 imgout.SetUpdateInformationCallback(imgin.GetUpdateInformationCallback());
 imgout.SetPipelineModifiedCallback(imgin.GetPipelineModifiedCallback());
 imgout.SetWholeExtentCallback(imgin.GetWholeExtentCallback());
 imgout.SetSpacingCallback(imgin.GetSpacingCallback());
 imgout.SetOriginCallback(imgin.GetOriginCallback());
 imgout.SetScalarTypeCallback(imgin.GetScalarTypeCallback());
 imgout.SetNumberOfComponentsCallback(imgin.GetNumberOfComponentsCallback());
 imgout.SetPropagateUpdateExtentCallback(imgin.GetPropagateUpdateExtentCallback());
 imgout.SetUpdateDataCallback(imgin.GetUpdateDataCallback());
 imgout.SetDataExtentCallback(imgin.GetDataExtentCallback());
 imgout.SetBufferPointerCallback(imgin.GetBufferPointerCallback());
 imgout.SetCallbackUserData(imgin.GetCallbackUserData());
 }
 */
 static Kitware.VTK.vtkImageData ConnectSWIGToActiviz(vtkgdcm.vtkImageData imgin)
 {
     HandleRef rawCppThis = imgin.GetCppThis();
     Kitware.VTK.vtkImageData imgout = new Kitware.VTK.vtkImageData( rawCppThis.Handle, false, false);
     return imgout;
 }