←Select platform

YuvParameters Property

Summary
Gets or sets the YUV conversion properties.
Syntax
C#
C++
public ConversionYuvParameters YuvParameters { get; set; } 
vb[VB Syntax] 
  
Public Property YuvParameters As ConversionYuvParameters 
public: 
property ConversionYuvParameters YuvParameters { 
   ConversionYuvParameters get(); 
   void set (    ConversionYuvParameters ); 
} 

Property Value

A ConversionYuvParameters structure that contains the CIELab conversion properties.

Remarks

The YUV conversion properties. If this property value is null(Nothing), default values are assumed.

Example

This example will convert a buffer from Yuv to Rgb Color Space.

C#
using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.ColorConversion; 
 
 
public byte[] GetYuvBufferFromImage(RasterImage bgrImage) 
{ 
   // StartUp the ColorConversion. 
   RasterColorConverterEngine.Startup(); 
 
   // Image buffer array 
   byte[] bgrBuffer = new byte[bgrImage.Width * bgrImage.Height * 3]; 
 
   bgrImage.Access(); 
   // get image buffer 
   for (int i = 0; i < bgrImage.Height; i++) 
      bgrImage.GetRow(i, bgrBuffer, (i * bgrImage.Width * 3), bgrImage.Width * 3); 
   bgrImage.Release(); 
 
   // Initialize a new Converter object 
   RasterColorConverterEngine converter = new RasterColorConverterEngine(); 
 
   byte[] yuvBuffer = new byte[bgrBuffer.Length]; 
 
   try 
   { 
      // Start the color conversion 
      converter.Start(ConversionColorFormat.Bgr, ConversionColorFormat.Yuv, null); 
 
      // convert the image buffer  
      converter.Convert(bgrBuffer, // input buffer 
         0, // offset from the beginning of the source buffer 
         yuvBuffer, // output buffer 
         0, // offset from the beginning of the destination buffer 
         bgrImage.Width, // pixels width 
         bgrImage.Height, // pixels height 
         0, // 0 bytes align 
         0); // 0 bytes align 
 
      // stop the conversion 
      converter.Stop(); 
   } 
   catch (Exception ex) 
   { 
      MessageBox.Show(ex.Message); 
   } 
 
   RasterColorConverterEngine.Shutdown(); 
 
   return yuvBuffer; 
} 
 
public RasterImage GetImageFromYuvBuffer(byte[] yuvBuffer, int width, int height) 
{ 
   // StartUp the ColorConversion. 
   RasterColorConverterEngine.Startup(); 
 
   // Initialize a new Converter object 
   RasterColorConverterEngine converter = new RasterColorConverterEngine(); 
 
   // Initialize an image to hold the converted buffer. 
   RasterImage yuvImage = null; 
   try 
   { 
      yuvImage = new RasterImage(RasterMemoryFlags.Conventional, width, height, 24, RasterByteOrder.Bgr, RasterViewPerspective.TopLeft, null, IntPtr.Zero, 0); 
 
      // Start the color conversion 
      converter.Start(ConversionColorFormat.Yuv, ConversionColorFormat.Bgr, null); 
 
      // convert the image buffer 
      converter.ConvertToImage(yuvBuffer, // converted buffer 
         0,                // offset from the beginning of the source buffer 
         yuvImage,        // image to be save 
         width,   // pixels width 
         height,  // pixels height 
         0,                // 0 bytes align 
         0);               // 0 bytes align 
 
      // stop the conversion 
      converter.Stop(); 
   } 
   catch (Exception ex) 
   { 
      MessageBox.Show(ex.Message); 
   } 
   // Shutdown the ColorConversion. 
   RasterColorConverterEngine.Shutdown(); 
   return yuvImage; 
} 
 
public void YuvParametersPropertyExample() 
{ 
   // Startup the RasterCodecs 
   RasterCodecs codecs = new RasterCodecs(); 
 
   // StartUp the ColorConversion. 
   RasterColorConverterEngine.Startup(); 
 
   // The input file name 
   string inputFileName = Path.Combine(LEAD_VARS.ImagesDir, "Image1.cmp"); 
 
   // load the input image as Bgr. 
   RasterImage bgrImage = codecs.Load(inputFileName, 24, CodecsLoadByteOrder.Bgr, 1, 1); 
 
   int width = bgrImage.Width; 
   int height = bgrImage.Height; 
 
   byte[] yuvBuffer = GetYuvBufferFromImage(bgrImage); 
 
   // Initialize the Rgb buffer array 
   byte[] rgbBuffer = new byte[yuvBuffer.Length]; 
 
   //Byte ordering of the format; for Y41P: 
   // U0 Y0 V0 Y1 U4 Y2 V4 Y3 Y4 Y5 Y6 Y7 
   // 0    1    2    3    4    5    6    7    8   9    10  11 
   // Put the Y component order first, then the U and V last as follows: 
   // Y positions: 1,3,5,7,8,9,10,11 
   // U positions: 0,4 
   // V positions: 2,6    
   int[] offset = { 1, 3, 5, 7, 8, 9, 10, 11, 0, 4, 2, 6 }; 
 
   // Initialize a new ConversionParameters class object. 
   ConversionParameters convParams = new ConversionParameters(); 
 
   // Initialize the YuvParameters class property. 
   ConversionYuvParameters yuvParameters = ConversionYuvParameters.Empty; 
 
   // Determine the horizontal sub-sampling of U 
   yuvParameters.UH = 4; 
 
   // Determine the vertical sub-sampling of U 
   yuvParameters.UV = 1; 
 
   // Determine the horizontal sub-sampling of V 
   yuvParameters.VH = 4; 
 
   // Determine the vertical sub-sampling of V 
   yuvParameters.VV = 1; 
 
   //Set the byte ordering 
   yuvParameters.Offsets = offset; 
 
   //The YUV values range 
   yuvParameters.Range = ConversionYuvRange.UseFull; 
 
   // This represents the macro pixels(smallest group of pixels allowed),  
   // which indicates how many actual pixels are in the macro pixel.  
   // This value is important only in non - planar format 
   yuvParameters.MacroPixel = 8; 
 
   //This is a Boolean value that represents the type of the YUV format (Planar = true, or non - Planar = false.) 
   yuvParameters.Planar = false; 
 
   // set the yuv parameters 
   convParams.YuvParameters = yuvParameters; 
 
   // Determine the type of conversion to be used in the conversion, for YUVGeneric, only use UseBuiltIn 
   convParams.Method = ConversionMethodFlags.UseBuiltIn; 
 
   //Determine the type of conversion to be activated. For YUVGeneric, only UseBuiltIn 
   convParams.ActiveMethod = ConversionMethodFlags.UseBuiltIn; 
 
   // Initialize a new Converter object 
   RasterColorConverterEngine converter = new RasterColorConverterEngine(); 
 
   try 
   { 
      //Initialize the conversion 
      converter.Start(ConversionColorFormat.Yuv, ConversionColorFormat.Rgb, convParams); 
 
      // Convert the Buffer from Yuv to Rgb 
      converter.Convert(yuvBuffer, 0, rgbBuffer, 0, width, height, 0, 0); 
 
      // Change the Yuv Parameters 
      convParams.Method = ConversionMethodFlags.ChangeYuv; 
 
      // Change the MacroPixel value 
      yuvParameters.Mask = ConversionYuvMaskFlags.MacroPixel; 
 
      // Reset the MacroPixel Property. 
      yuvParameters.MacroPixel = 16; 
      convParams.YuvParameters = yuvParameters; 
 
      // Convert the Buffer from Yuv to Rgb 
      converter.Convert(yuvBuffer, 0, rgbBuffer, 0, width, height, 0, 0); 
 
      // Stop the conversion 
      converter.Stop(); 
   } 
   catch (Exception ex) 
   { 
      MessageBox.Show(ex.Message); 
      rgbBuffer = null; 
   } 
 
   // the output File Name. 
   string outputFileName = Path.Combine(LEAD_VARS.ImagesDir, "ResultImage.bmp"); 
 
   // Save the converted Image 
   RasterImage yuvImage = GetImageFromYuvBuffer(yuvBuffer, width, height); 
   codecs.Save(yuvImage, outputFileName, RasterImageFormat.Bmp, 24); 
 
   // Shutdown the ColorConversion. 
   RasterColorConverterEngine.Shutdown(); 
 
   // Shutdown the RasterCodecs 
} 
 
static class LEAD_VARS 
{ 
   public const string ImagesDir = @"C:\LEADTOOLS22\Resources\Images"; 
} 
Requirements

Target Platforms

Help Version 22.0.2022.4.4
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2022 LEAD Technologies, Inc. All Rights Reserved.

Leadtools.ColorConversion Assembly

Products | Support | Contact Us | Intellectual Property Notices
© 1991-2022 LEAD Technologies, Inc. All Rights Reserved.