DICOM.cs

using System;
using System.Runtime.InteropServices;
using UnityEngine;
using itk.simple;
using System.Collections.Generic;

public class DICOM {

    public DICOMSeries seriesInfo { private set; get; }
    public int dimensions { protected set; get; }
    public int texWidth { protected set; get; }
    public int texHeight { protected set; get; }
    public int texDepth { protected set; get; }

    public int origTexWidth { protected set; get; }
    public int origTexHeight { protected set; get; }
    public int origTexDepth { protected set; get; }

    public int texPaddingWidth { protected set; get; }
    public int texPaddingHeight { protected set; get; }
    public int texPaddingDepth { protected set; get; }

    public Image image { protected set; get; }

    public Vector3 origin { protected set; get; }
    public Vector2 pixelSpacing { protected set; get; }

    public Vector3 sliceOffset { get {return seriesInfo.sliceOffset;} }

    public Vector3 directionCosineX { protected set; get; }
    public Vector3 directionCosineY { protected set; get; }

    public Vector3 sliceNormal { protected set; get; }

    public Matrix4x4 pixelToPatient { protected set; get; }

    public Matrix4x4 patientToPixel { protected set; get; }

    public DICOM( DICOMSeries seriesInfo ) {
        
        // Remember, we will need it later:
        this.seriesInfo = seriesInfo;
    }

    // ===============================================================
    // Transformations:

    public void setupTransformationMatrices()
    {
        // Set up the transformation matrix:
        Matrix4x4 transformMatrix = new Matrix4x4 ();
        // Column 1:
        transformMatrix [0, 0] = directionCosineX.x * pixelSpacing.x;
        transformMatrix [1, 0] = directionCosineX.y * pixelSpacing.x;
        transformMatrix [2, 0] = directionCosineX.z * pixelSpacing.x;
        transformMatrix [3, 0] = 0f;
        // Column 2:
        transformMatrix [0, 1] = directionCosineY.x * pixelSpacing.y;
        transformMatrix [1, 1] = directionCosineY.y * pixelSpacing.y;
        transformMatrix [2, 1] = directionCosineY.z * pixelSpacing.y;
        transformMatrix [3, 1] = 0f;
        // Column 3:
        transformMatrix [0, 2] = sliceOffset.x;
        transformMatrix [1, 2] = sliceOffset.y;
        transformMatrix [2, 2] = sliceOffset.z;
        transformMatrix [3, 2] = 0f;
        // Column 4:
        transformMatrix [0, 3] = origin.x;
        transformMatrix [1, 3] = origin.y;
        transformMatrix [2, 3] = origin.z;
        transformMatrix [3, 3] = 1f;

        // Convert to a the left-hand-side coordinate system which Unity uses:
        Matrix4x4 rightHandToLeftHand = new Matrix4x4 ();
        rightHandToLeftHand [0, 0] = 1f;
        rightHandToLeftHand [1, 1] = 1f;
        rightHandToLeftHand [2, 2] = -1f;
        rightHandToLeftHand [3, 3] = 1f;

        pixelToPatient = rightHandToLeftHand*transformMatrix;

        // Inverse transformation:
        patientToPixel = pixelToPatient.inverse;
    }
    public Vector3 transformPixelToPatientPos( Vector2 pixel, float layer = 0 )
    {
        Vector4 p = new Vector4 (pixel.x, pixel.y, layer, 1f);
        Vector4 pos = pixelToPatient * p;
        return new Vector3 (pos.x, pos.y, pos.z);
    }

    public Vector3 transformPatientPosToPixel( Vector3 pos )
    {
        Vector4 p = new Vector4 (pos.x, pos.y, pos.z, 1f);
        Vector4 pixel = patientToPixel * p;
        return new Vector3 (pixel.x, pixel.y, pixel.z);
    }

    public Vector3 transformPatientPosToDiscretePixel( Vector3 pos )
    {
        Vector3 pixel = transformPatientPosToPixel( pos );
        Vector3 rounded = new Vector3 (Mathf.Round (pixel.x),
            Mathf.Round (pixel.y),
            Mathf.Round (pixel.z));
        return rounded;
    }

    public static Color32 F2C(UInt32 value)
    {
        Color32 c = new Color32 ();

        /*c.r = (byte)(value % 256); value /= 256;
        c.g = (byte)(value % 256); value /= 256;
        c.b = (byte)(value % 256); value /= 256;
        c.a = (byte)(value % 256);*/

        /*c.r = (byte)(value % 256); value = value >> 8;
        c.g = (byte)(value % 256); value = value >> 8;
        c.b = (byte)(value % 256); value = value >> 8;
        c.a = (byte)(value % 256);*/
        c.a = (byte)(value >> 24);
        c.b = (byte)(value >> 16);
        c.g = (byte)(value >> 8);
        c.r = (byte)(value);
        //Debug.LogWarning ("c: " + c.r + " " + c.g + " " + c.b + "  " + c.a);

        return c;
    }
    /*public static Color F2C(Int16 value)
    {
        UInt32 valueUInt = (UInt32)((int)value + 32768);
        return F2C (valueUInt);
    }*/
    /*public static Color F2C(UInt16 value)
    {
        UInt32 valueUInt = (UInt32)(value);
        return F2C (valueUInt);
    }*/
}