Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Dicom Printer

Created 12 months agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

334 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

354 lines

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.Threading.Tasks;

using FellowOakDicom;

using FellowOakDicom.Imaging;

using FellowOakDicom.IO;

using FellowOakDicom.Network;

using FellowOakDicom.Printing;

using FellowOakDicom.Network.Client;

using FellowOakDicom.IO.Buffer;

using System.IO;

using System.Printing;

namespace libd2print

{

internal class DicomPrinter

{

private static DicomPrinter _instance;

public static DicomPrinter I

{

get

{

if (_instance == null)

{

_instance = new DicomPrinter();

}

return _instance;

}

public async Task Print(string RemoteAddress, int RemotePort, string CallingAE, string CalledAE, string FullPrintJobFolder, int pages)

{

var printJob = new PrintJobDicom("DICOM PRINT JOB", "BLUE FILM")

{

RemoteAddress = RemoteAddress,

RemotePort = RemotePort,

CallingAE = CallingAE,// printscu

CallingAE = CallingAE,// print scu

CalledAE = CalledAE //print scp

};

//greyscale

var testPath = Path.Combine(FullPrintJobFolder);

//var greyscaleImg = new DicomImage(testPath + "/I000001.dcm");

var i = 0;

while (i < pages)

{

Image Dummy = Image.FromFile(testPath + "/" + (i + 1).ToString() + ".png");

using (var dum = Dummy)

{

Bitmap bmp = new Bitmap(dum);

using (var bitmap = bmp)

{

printJob.FilmSession.IsColor = false; //set to true to print in color

printJob.StartFilmBox("STANDARD\\1,1", "PORTRAIT", "10INX14IN", "BILINEAR");

printJob.StartFilmBox("STANDARD\\1,1", "PORTRAIT", "8INX10IN", "CUBIC");

printJob.AddImage(bitmap, 0);

}

i++;

}

printJob.EndFilmBox();

await printJob.Print();

}

internal class PrintJobDicom

{

public string CallingAE { get; set; }

public string CalledAE { get; set; }

public string RemoteAddress { get; set; }

public int RemotePort { get; set; }

public FilmSession FilmSession { get; private set; }

private FilmBox _currentFilmBox;

public PrintJobDicom(string jobLabel, string mediumType = "PAPER")

{

FilmSession = new FilmSession(DicomUID.BasicFilmSession)

{

FilmSessionLabel = jobLabel,

MediumType = mediumType,

NumberOfCopies = 1

NumberOfCopies = 1,

PrintPriority = "MED",

FilmDestination = "BIN_1",

};

FilmSession.FilmSessionLabel = "";

}

public FilmBox StartFilmBox(string format, string orientation, string filmSize, string magnificationType = "NONE")

{

var filmBox = new FilmBox(FilmSession, null, DicomTransferSyntax.ExplicitVRLittleEndian)

{

ImageDisplayFormat = format,

FilmOrientation = orientation,

FilmSizeID = filmSize,

MagnificationType = magnificationType,

BorderDensity = "WHITE",

EmptyImageDensity = "BLACK",

//EmptyImageDensity = "BLACK",

Trim = "YES"

//Trim = "YES"

};

filmBox.AnnotationDisplayFormatID = "0";

filmBox.SmoothingType = "5";

filmBox.Illumination = 2000;

filmBox.ReflectedAmbientLight = 10;

filmBox.Trim = "NO";

filmBox.Initialize();

FilmSession.BasicFilmBoxes.Add(filmBox);

_currentFilmBox = filmBox;

return filmBox;

}

public void AddImage(Bitmap bitmap, int index)

{

if (FilmSession.IsColor)

{

AddColorImage(bitmap, index);

}

else

{

AddGreyscaleImage(bitmap, index);

}

private void AddGreyscaleImage(Bitmap bitmap, int index)

{

if (_currentFilmBox == null)

{

throw new InvalidOperationException("Start film box first!");

}

if (index < 0 || index > _currentFilmBox.BasicImageBoxes.Count)

{

throw new ArgumentOutOfRangeException(nameof(index), "Image box index out of range");

}

if (bitmap.PixelFormat != PixelFormat.Format24bppRgb && bitmap.PixelFormat != PixelFormat.Format32bppArgb

&& bitmap.PixelFormat != PixelFormat.Format32bppRgb)

{

throw new ArgumentException("Not supported bitmap format", nameof(bitmap));

}

var dataset = new DicomDataset();

dataset.Add<ushort>(DicomTag.Columns, (ushort)bitmap.Width)

.Add<ushort>(DicomTag.Rows, (ushort)bitmap.Height)

.Add<ushort>(DicomTag.BitsAllocated, 8)

.Add<ushort>(DicomTag.BitsStored, 8)

.Add<ushort>(DicomTag.HighBit, 7)

.Add(DicomTag.PixelRepresentation, (ushort)PixelRepresentation.Unsigned)

.Add(DicomTag.PlanarConfiguration, (ushort)PlanarConfiguration.Interleaved)

.Add<ushort>(DicomTag.SamplesPerPixel, 1)

.Add<ushort>(DicomTag.SamplesPerPixel, 1)//OK

.Add(DicomTag.PhotometricInterpretation, PhotometricInterpretation.Rgb.Value);

.Add(DicomTag.PhotometricInterpretation, PhotometricInterpretation.Monochrome2);

dataset.Add(DicomTag.PixelAspectRatio, 1);

dataset.Add(DicomTag.PixelRepresentation, "0000H");

dataset.Add(DicomTag.Polarity, "NORMAL");

dataset.Add(DicomTag.MagnificationType, "CUBIC");

dataset.Add(DicomTag.SmoothingType, 5);

dataset.Add(DicomTag.ConfigurationInformation, "LUT=Ver693c0.w87,6");

dataset.Add(DicomTag.RequestedImageSize, "0.00");

dataset.Add(DicomTag.RequestedDecimateCropBehavior, "DECIMATE");

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetGreyBytes(bitmap);

var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];

imageBox.ImageSequence = dataset;

pixels.Dispose();

}

private void AddColorImage(Bitmap bitmap, int index)

{

if (_currentFilmBox == null)

{

throw new InvalidOperationException("Start film box first!");

}

if (index < 0 || index > _currentFilmBox.BasicImageBoxes.Count)

{

throw new ArgumentOutOfRangeException(nameof(index), "Image box index out of range");

}

if (bitmap.PixelFormat != PixelFormat.Format24bppRgb && bitmap.PixelFormat != PixelFormat.Format32bppArgb

&& bitmap.PixelFormat != PixelFormat.Format32bppRgb)

{

throw new ArgumentException("Not supported bitmap format", nameof(bitmap));

}

var dataset = new DicomDataset();

dataset.Add<ushort>(DicomTag.Columns, (ushort)bitmap.Width)

.Add<ushort>(DicomTag.Rows, (ushort)bitmap.Height)

.Add<ushort>(DicomTag.BitsAllocated, 8)

.Add<ushort>(DicomTag.BitsStored, 8)

.Add<ushort>(DicomTag.HighBit, 7)

.Add(DicomTag.PixelRepresentation, (ushort)PixelRepresentation.Unsigned)

.Add(DicomTag.PlanarConfiguration, (ushort)PlanarConfiguration.Interleaved)

.Add<ushort>(DicomTag.SamplesPerPixel, 3)

.Add(DicomTag.PhotometricInterpretation, PhotometricInterpretation.Rgb.Value);

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetColorbytes(bitmap);

var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];

imageBox.ImageSequence = dataset;

pixels.Dispose();

}

public void EndFilmBox()

{

_currentFilmBox = null;

}

public async Task Print()

{

var dicomClient = DicomClientFactory.Create(RemoteAddress, RemotePort, false, CallingAE, CalledAE);

await dicomClient.AddRequestAsync(

new DicomNCreateRequest(FilmSession.SOPClassUID, FilmSession.SOPInstanceUID)

{

Dataset = FilmSession

});

foreach (var filmbox in FilmSession.BasicFilmBoxes)

{

var imageBoxRequests = new List<DicomNSetRequest>();

var filmBoxRequest = new DicomNCreateRequest(FilmBox.SOPClassUID, filmbox.SOPInstanceUID)

{

Dataset = filmbox

};

filmBoxRequest.OnResponseReceived = (request, response) =>

{

if (response.HasDataset)

{

var seq = response.Dataset.GetSequence(DicomTag.ReferencedImageBoxSequence);

for (int i = 0; i < seq.Items.Count; i++)

{

var req = imageBoxRequests[i];

var imageBox = req.Dataset;

var sopInstanceUid = seq.Items[i].GetSingleValue<string>(DicomTag.ReferencedSOPInstanceUID);

imageBox.AddOrUpdate(DicomTag.SOPInstanceUID, sopInstanceUid);

req.Command.AddOrUpdate(DicomTag.RequestedSOPInstanceUID, sopInstanceUid);

}

};

await dicomClient.AddRequestAsync(filmBoxRequest);

foreach (var image in filmbox.BasicImageBoxes)

{

var req = new DicomNSetRequest(image.SOPClassUID, image.SOPInstanceUID) { Dataset = image };

imageBoxRequests.Add(req);

await dicomClient.AddRequestAsync(req);

}

await dicomClient.AddRequestAsync(new DicomNActionRequest(FilmSession.SOPClassUID, FilmSession.SOPInstanceUID, 0x0001));

await dicomClient.SendAsync();

}

private unsafe PinnedByteArray GetGreyBytes(Bitmap bitmap)

{

var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height);

var data = bitmap.LockBits(

new Rectangle(0, 0, bitmap.Width, bitmap.Height),

ImageLockMode.ReadOnly,

bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;

var srcLine = (byte*)data.Scan0.ToPointer();

for (int i = 0; i < data.Height; i++)

{

for (int j = 0; j < data.Width; j++)

{

var pixel = srcLine + j * srcComponents;

int grey = (int)(pixel[0] * 0.3 + pixel[1] * 0.59 + pixel[2] * 0.11);

dstLine[j] = (byte)grey;

}

srcLine += data.Stride;

dstLine += data.Width;

}

bitmap.UnlockBits(data);

return pixels;

}

private unsafe PinnedByteArray GetColorbytes(Bitmap bitmap)

{

var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height * 3);

var data = bitmap.LockBits(

new Rectangle(0, 0, bitmap.Width, bitmap.Height),

ImageLockMode.ReadOnly,

bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;

var srcLine = (byte*)data.Scan0.ToPointer();

for (int i = 0; i < data.Height; i++)

{

for (int j = 0; j < data.Width; j++)

{

var srcPixel = srcLine + j * srcComponents;

var dstPixel = dstLine + j * 3;

//convert from bgr to rgb

dstPixel[0] = srcPixel[2];

dstPixel[1] = srcPixel[1];

dstPixel[2] = srcPixel[0];

}

srcLine += data.Stride;

dstLine += data.Width * 3;

}

bitmap.UnlockBits(data);

return pixels;

}

Saved diffs

Original text

Open file

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading.Tasks;
using FellowOakDicom;
using FellowOakDicom.Imaging;
using FellowOakDicom.IO;
using FellowOakDicom.Network;
using FellowOakDicom.Printing;
using FellowOakDicom.Network.Client;
using FellowOakDicom.IO.Buffer;
using System.IO;

namespace libd2print
{

internal class DicomPrinter
    {
        private static DicomPrinter _instance;

public static DicomPrinter I
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new DicomPrinter();
                }
                return _instance;
            }

}

public async Task Print(string RemoteAddress, int RemotePort, string CallingAE, string CalledAE, string FullPrintJobFolder, int pages)
        {
            var printJob = new PrintJobDicom("DICOM PRINT JOB", "BLUE FILM")
            {
                RemoteAddress = RemoteAddress,
                RemotePort = RemotePort,
                CallingAE = CallingAE,// printscu
                CalledAE = CalledAE  //print scp
            };

//greyscale

var testPath = Path.Combine(FullPrintJobFolder);
            //var greyscaleImg = new DicomImage(testPath + "/I000001.dcm");

await printJob.Print();
        }
    }

internal class PrintJobDicom
    {
        public string CallingAE { get; set; }
        public string CalledAE { get; set; }
        public string RemoteAddress { get; set; }
        public int RemotePort { get; set; }

public FilmSession FilmSession { get; private set; }

private FilmBox _currentFilmBox;

public PrintJobDicom(string jobLabel, string mediumType = "PAPER")
        {
            FilmSession = new FilmSession(DicomUID.BasicFilmSession)
            {
                FilmSessionLabel = jobLabel,
                MediumType = mediumType,
                NumberOfCopies = 1
            };
        }

public FilmBox StartFilmBox(string format, string orientation, string filmSize, string magnificationType = "NONE")
        {
            var filmBox = new FilmBox(FilmSession, null, DicomTransferSyntax.ExplicitVRLittleEndian)
            {
                ImageDisplayFormat = format,
                FilmOrientation = orientation,
                FilmSizeID = filmSize,
                MagnificationType = magnificationType,
                BorderDensity = "WHITE",
                EmptyImageDensity = "BLACK",
                Trim = "YES"
            };

filmBox.Initialize();
            FilmSession.BasicFilmBoxes.Add(filmBox);

_currentFilmBox = filmBox;
            return filmBox;
        }

public void AddImage(Bitmap bitmap, int index)
        {
            if (FilmSession.IsColor)
            {
                AddColorImage(bitmap, index);
            }
            else
            {
                AddGreyscaleImage(bitmap, index);
            }
        }

private void AddGreyscaleImage(Bitmap bitmap, int index)
        {
            if (_currentFilmBox == null)
            {
                throw new InvalidOperationException("Start film box first!");
            }
            if (index < 0 || index > _currentFilmBox.BasicImageBoxes.Count)
            {
                throw new ArgumentOutOfRangeException(nameof(index), "Image box index out of range");
            }

if (bitmap.PixelFormat != PixelFormat.Format24bppRgb && bitmap.PixelFormat != PixelFormat.Format32bppArgb
                && bitmap.PixelFormat != PixelFormat.Format32bppRgb)
            {
                throw new ArgumentException("Not supported bitmap format", nameof(bitmap));
            }

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetGreyBytes(bitmap);
            var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];
            imageBox.ImageSequence = dataset;

pixels.Dispose();
        }

private void AddColorImage(Bitmap bitmap, int index)
        {
            if (_currentFilmBox == null)
            {
                throw new InvalidOperationException("Start film box first!");
            }
            if (index < 0 || index > _currentFilmBox.BasicImageBoxes.Count)
            {
                throw new ArgumentOutOfRangeException(nameof(index), "Image box index out of range");
            }

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetColorbytes(bitmap);
            var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];
            imageBox.ImageSequence = dataset;

pixels.Dispose();
        }

public void EndFilmBox()
        {
            _currentFilmBox = null;
        }

public async Task Print()
        {
            var dicomClient = DicomClientFactory.Create(RemoteAddress, RemotePort, false, CallingAE, CalledAE);

await dicomClient.AddRequestAsync(
                new DicomNCreateRequest(FilmSession.SOPClassUID, FilmSession.SOPInstanceUID)
                {
                    Dataset = FilmSession
                });

foreach (var filmbox in FilmSession.BasicFilmBoxes)
            {

var imageBoxRequests = new List<DicomNSetRequest>();

foreach (var image in filmbox.BasicImageBoxes)
                {
                    var req = new DicomNSetRequest(image.SOPClassUID, image.SOPInstanceUID) { Dataset = image };

imageBoxRequests.Add(req);
                    await dicomClient.AddRequestAsync(req);
                }
            }

await dicomClient.AddRequestAsync(new DicomNActionRequest(FilmSession.SOPClassUID, FilmSession.SOPInstanceUID, 0x0001));

await dicomClient.SendAsync();
        }

private unsafe PinnedByteArray GetGreyBytes(Bitmap bitmap)
        {
            var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height);

var data = bitmap.LockBits(
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly,
                bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;
            var srcLine = (byte*)data.Scan0.ToPointer();

for (int i = 0; i < data.Height; i++)
            {
                for (int j = 0; j < data.Width; j++)
                {
                    var pixel = srcLine + j * srcComponents;
                    int grey = (int)(pixel[0] * 0.3 + pixel[1] * 0.59 + pixel[2] * 0.11);
                    dstLine[j] = (byte)grey;
                }

srcLine += data.Stride;
                dstLine += data.Width;
            }
            bitmap.UnlockBits(data);

return pixels;
        }

private unsafe PinnedByteArray GetColorbytes(Bitmap bitmap)
        {
            var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height * 3);

var data = bitmap.LockBits(
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly,
                bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;
            var srcLine = (byte*)data.Scan0.ToPointer();

for (int i = 0; i < data.Height; i++)
            {
                for (int j = 0; j < data.Width; j++)
                {
                    var srcPixel = srcLine + j * srcComponents;
                    var dstPixel = dstLine + j * 3;

//convert from bgr to rgb
                    dstPixel[0] = srcPixel[2];
                    dstPixel[1] = srcPixel[1];
                    dstPixel[2] = srcPixel[0];
                }

srcLine += data.Stride;
                dstLine += data.Width * 3;
            }
            bitmap.UnlockBits(data);

return pixels;
        }

}
}

Changed text

Open file

namespace libd2print
{

internal class DicomPrinter
    {
        private static DicomPrinter _instance;

}

public async Task Print(string RemoteAddress, int RemotePort, string CallingAE, string CalledAE, string FullPrintJobFolder, int pages)
        {
            var printJob = new PrintJobDicom("DICOM PRINT JOB", "BLUE FILM")
            {
                RemoteAddress = RemoteAddress,
                RemotePort = RemotePort,
                CallingAE = CallingAE,// print scu
                CalledAE = CalledAE  //print scp
            };

//greyscale

var testPath = Path.Combine(FullPrintJobFolder);
            //var greyscaleImg = new DicomImage(testPath + "/I000001.dcm");

await printJob.Print();
        }
    }

public FilmSession FilmSession { get; private set; }

private FilmBox _currentFilmBox;

FilmSession.FilmSessionLabel = "";
        }

public FilmBox StartFilmBox(string format, string orientation, string filmSize, string magnificationType = "NONE")
        {
            var filmBox = new FilmBox(FilmSession, null, DicomTransferSyntax.ExplicitVRLittleEndian)
            {
                ImageDisplayFormat = format,
                FilmOrientation = orientation,
                FilmSizeID = filmSize,
                MagnificationType = magnificationType,
                BorderDensity = "WHITE",
                //EmptyImageDensity = "BLACK",
                //Trim = "YES"
            };

filmBox.AnnotationDisplayFormatID = "0";
            filmBox.SmoothingType = "5";
            filmBox.Illumination = 2000;
            filmBox.ReflectedAmbientLight = 10;
            filmBox.Trim = "NO";

filmBox.Initialize();
            FilmSession.BasicFilmBoxes.Add(filmBox);

_currentFilmBox = filmBox;
            return filmBox;
        }

var dataset = new DicomDataset();
            dataset.Add<ushort>(DicomTag.Columns, (ushort)bitmap.Width)
                .Add<ushort>(DicomTag.Rows, (ushort)bitmap.Height)
                .Add<ushort>(DicomTag.BitsAllocated, 8)
                .Add<ushort>(DicomTag.BitsStored, 8)
                .Add<ushort>(DicomTag.HighBit, 7)
                .Add(DicomTag.PixelRepresentation, (ushort)PixelRepresentation.Unsigned)
                .Add(DicomTag.PlanarConfiguration, (ushort)PlanarConfiguration.Interleaved)
                .Add<ushort>(DicomTag.SamplesPerPixel, 1)//OK 
                .Add(DicomTag.PhotometricInterpretation, PhotometricInterpretation.Monochrome2);
            dataset.Add(DicomTag.PixelAspectRatio, 1);
            dataset.Add(DicomTag.PixelRepresentation, "0000H");
            dataset.Add(DicomTag.Polarity, "NORMAL");
            dataset.Add(DicomTag.MagnificationType, "CUBIC");
            dataset.Add(DicomTag.SmoothingType, 5);
            dataset.Add(DicomTag.ConfigurationInformation, "LUT=Ver693c0.w87,6");
            dataset.Add(DicomTag.RequestedImageSize, "0.00");
            dataset.Add(DicomTag.RequestedDecimateCropBehavior, "DECIMATE");

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetGreyBytes(bitmap);
            var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];
            imageBox.ImageSequence = dataset;

pixels.Dispose();
        }

var pixelData = DicomPixelData.Create(dataset, true);

var pixels = GetColorbytes(bitmap);
            var buffer = new MemoryByteBuffer(pixels.Data);

pixelData.AddFrame(buffer);

var imageBox = _currentFilmBox.BasicImageBoxes[index];
            imageBox.ImageSequence = dataset;

pixels.Dispose();
        }

public void EndFilmBox()
        {
            _currentFilmBox = null;
        }

public async Task Print()
        {
            var dicomClient = DicomClientFactory.Create(RemoteAddress, RemotePort, false, CallingAE, CalledAE);

foreach (var filmbox in FilmSession.BasicFilmBoxes)
            {

var imageBoxRequests = new List<DicomNSetRequest>();

foreach (var image in filmbox.BasicImageBoxes)
                {
                    var req = new DicomNSetRequest(image.SOPClassUID, image.SOPInstanceUID) { Dataset = image };

imageBoxRequests.Add(req);
                    await dicomClient.AddRequestAsync(req);
                }
            }

await dicomClient.AddRequestAsync(new DicomNActionRequest(FilmSession.SOPClassUID, FilmSession.SOPInstanceUID, 0x0001));

await dicomClient.SendAsync();
        }

private unsafe PinnedByteArray GetGreyBytes(Bitmap bitmap)
        {
            var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height);

var data = bitmap.LockBits(
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly,
                bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;
            var srcLine = (byte*)data.Scan0.ToPointer();

srcLine += data.Stride;
                dstLine += data.Width;
            }
            bitmap.UnlockBits(data);

return pixels;
        }

private unsafe PinnedByteArray GetColorbytes(Bitmap bitmap)
        {
            var pixels = new PinnedByteArray(bitmap.Width * bitmap.Height * 3);

var data = bitmap.LockBits(
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly,
                bitmap.PixelFormat);

var srcComponents = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

var dstLine = (byte*)pixels.Pointer;
            var srcLine = (byte*)data.Scan0.ToPointer();

//convert from bgr to rgb
                    dstPixel[0] = srcPixel[2];
                    dstPixel[1] = srcPixel[1];
                    dstPixel[2] = srcPixel[0];
                }

srcLine += data.Stride;
                dstLine += data.Width * 3;
            }
            bitmap.UnlockBits(data);

return pixels;
        }

}
}