Exemplo n.º 1
0
        /// <summary>
        /// Transforms each voxel position from the source image to a new position.
        /// </summary>
        /// <param name="sourceMatrix">The image which will provide the voxel values.</param>
        /// <param name="transformationMatrix">This matrix will be applied to the original positions to get a new position.</param>
        /// <returns></returns>
        public static Image3DMatrix Transform(Image3DMatrix sourceMatrix, TransformationMatrix transformationMatrix)
        {
            sourceMatrix.CancelParallelTransformation();
            ParallelOptions options = CreateParallelOptions(sourceMatrix);

            //Before returning a new matrix, the transformed points are collected. In the last step, these points will
            //be analyzed to receive the new height, width and depth of the matrix after the transformation.
            ConcurrentDictionary <(int X, int Y, int Z), ushort> transformedPoints = new ConcurrentDictionary <(int X, int Y, int Z), ushort>();

            try
            {
                //Due to using target to source exactly one value will be asigned for each position, so it is save
                //to run the process with parallel for loops.
                Parallel.For(0, sourceMatrix.Depth, options, (z) =>
                {
                    Parallel.For(0, sourceMatrix.Height, options, (y) =>
                    {
                        Parallel.For(0, sourceMatrix.Width, options, (x) =>
                        {
                            ushort targetValue = sourceMatrix[z, y, x];

                            var targetPoint = ApplyTransformationMatrix(x, y, z, transformationMatrix);
                            transformedPoints[targetPoint] = targetValue;
                        });
                    });
                });
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Operation Cancelled");
            }
            return(CreateNewSizedMatrix(transformedPoints, sourceMatrix.BytePerPixel));
        }
Exemplo n.º 2
0
        public IEnumerable <WriteableBitmap> Build()
        {
            Image3DMatrix        imageMatrix          = _imageLoader.GetImageMatrix();
            TransformationMatrix transformationMatrix = GetTransformationMatrix(imageMatrix);

            imageMatrix = ApplyTransformationMatrix(imageMatrix, transformationMatrix);

            return(MatrixToBitmapImageConverter.GetImages(imageMatrix));
        }
Exemplo n.º 3
0
        private Image3DMatrix ApplyTransformationMatrix(Image3DMatrix imageMatrix, TransformationMatrix transformationMatrix)
        {
            if (transformationMatrix != TransformationMatrix.UnitMatrix4x4)
            {
                imageMatrix = Image3DMatrix.Transform(imageMatrix, transformationMatrix);
            }

            return(imageMatrix);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Applies a function to every voxel of the image.
 /// </summary>
 /// <param name="sourceMatrix">The image which will provide the original voxel values.</param>
 /// <param name="targetMatrix">The image where the new values will be stored.</param>
 /// <param name="action">This function gets the position of the original voxel and returns a value for it.</param>
 /// /// <returns>The targetMatrix will be returned.</returns>
 public static Image3DMatrix Map(Image3DMatrix sourceMatrix, Image3DMatrix targetMatrix, Func <int, int, int, ushort> action)
 {
     for (int z = 0; z < sourceMatrix.Depth; z++)
     {
         for (int y = 0; y < sourceMatrix.Height; y++)
         {
             for (int x = 0; x < sourceMatrix.Width; x++)
             {
                 targetMatrix[z, y, x] = action(x, y, z);
             }
         }
     }
     return(targetMatrix);
 }
Exemplo n.º 5
0
        private TransformationMatrix GetTransformationMatrix(Image3DMatrix imageMatrix)
        {
            if (imageMatrix != null)
            {
                //The transformations will be concatenated here. However, it is possible that
                //some combinations of parameters do need lead to correct results, because
                //transformations are not cumulative.
                TransformationMatrix transformationMatrix = TransformationMatrix.
                                                            UnitMatrix4x4.
                                                            Shear3D(Bxy, Byx, Bxz, Bzx, Byz, Bzy).
                                                            Scale3D(Sx, Sy, Sz).
                                                            RotateX3D(AlphaX).
                                                            RotateY3D(AlphaY).
                                                            RotateZ3D(AlphaZ).
                                                            Shift3D(Dx, Dy, Dz);

                return(transformationMatrix);
            }
            return(TransformationMatrix.UnitMatrix4x4);
        }
Exemplo n.º 6
0
        public static IEnumerable <WriteableBitmap> GetImages(Image3DMatrix imageMatrix)
        {
            if (imageMatrix != null)
            {
                int height       = imageMatrix.Height;
                int width        = imageMatrix.Width;
                int depth        = imageMatrix.Depth;
                int bitsPerPixel = 8 * imageMatrix.BytePerPixel;

                WriteableBitmap[] bitmaps = new WriteableBitmap[depth];

                for (int layer = 0; layer < depth; layer++)
                {
                    byte[]          imageBytes = imageMatrix.GetBytes(layer);
                    WriteableBitmap bitmap     = CreateWriteableBitmap(height, width, bitsPerPixel, imageBytes);
                    //Must be freezed to share it between threads.
                    bitmap.Freeze();
                    bitmaps[layer] = bitmap;
                }

                return(bitmaps);
            }
            return(Array.Empty <WriteableBitmap>());
        }
Exemplo n.º 7
0
 /// <summary>
 /// Applies a function to every voxel of the image.
 /// </summary>
 /// <param name="sourceMatrix">The image which will provide the original voxel values.</param>
 /// <param name="targetMatrix">The image where the new values will be stored.</param>
 /// <param name="action">This function gets the original voxel value and returns a new one.</param>
 /// <returns>The targetMatrix will be returned.</returns>
 public static Image3DMatrix Map(Image3DMatrix sourceMatrix, Image3DMatrix targetMatrix, Func <ushort, ushort> action)
 {
     return(Map(sourceMatrix, targetMatrix, (x, y, z) => action(sourceMatrix[z, y, x])));
 }