डेल्फी से सी #

Question

से एचएसवी सर्कल कोड कनवर्ट करना मैं डेल्फी से सी # तक एचएसवी सर्किल बनाने के लिए एक फ़ंक्शन को कन्वर्ट करने की कोशिश कर रहा हूं, लेकिन परिणाम सही तरीके से नहीं हो रहा है।

मेरा लक्ष्य विंडोज फोन 7 के लिए एक ऐप करना है, और मैं केवल WP7.1 एसडीके, प्लस WriteableBitmapEx लाइब्रेरी का उपयोग कर रहा हूं।

डेल्फी कोड:

FUNCTION CreateHueSaturationCircle(CONST size: INTEGER; CONST ValueLevel: INTEGER; CONST BackgroundColor: TColor): TBitmap; 
VAR 
    dSquared: INTEGER; 
    H,S,V: INTEGER; 
    i: INTEGER; 
    j: INTEGER; 
    Radius: INTEGER; 
    RadiusSquared: INTEGER; 
    row: pRGBTripleArray; 
    X: INTEGER; 
    Y: INTEGER; 
BEGIN 
    RESULT := TBitmap.Create; 
    RESULT.PixelFormat := pf24bit; 
    RESULT.Width := size; 
    RESULT.Height := size; 

    // Fill with background color 
    RESULT.Canvas.Brush.Color := BackGroundColor; 
    RESULT.Canvas.FillRect(RESULT.Canvas.ClipRect); 

    Radius := size DIV 2; 
    RadiusSquared := Radius * Radius; 

    V := ValueLevel; 
    FOR j := 0 TO RESULT.Height - 1 DO 
    BEGIN 
     Y := Size - 1 - j - Radius; {Center is Radius offset} 
     row := RESULT.Scanline[Size - 1 - j]; 
     FOR i := 0 TO RESULT.Width - 1 DO 
     BEGIN 
      X := i - Radius; 
      dSquared := X * X + Y * Y; 
      IF dSquared <= RadiusSquared THEN 
      BEGIN 
       S := ROUND((255 * SQRT(dSquared))/Radius); 
       H := ROUND(180 * (1 + ArcTan2(X, Y)/PI)); // 0..360 degrees 
       // Shift 90 degrees so H=0 (red) occurs along "X" axis 
       H := H + 90; 
       IF H > 360 THEN 
        H := H - 360; 
       row[i] := HSVtoRGBTriple(H,S,V) 
      END 
     END; 
    END; 
END; 

FUNCTION HSVtoRGBTriple(CONST H,S,V: INTEGER): TRGBTriple; 
CONST 
    divisor: INTEGER = 255 * 60; 
VAR 
    f: INTEGER; 
    hTemp: INTEGER; 
    p,q,t: INTEGER; 
    VS: INTEGER; 
BEGIN 
    IF S = 0 THEN 
     RESULT := RGBtoRGBTriple(V, V, V) // achromatic: shades of gray 
    ELSE 
    BEGIN        // chromatic color 
     IF H = 360 THEN 
      hTemp := 0 
     ELSE 
      hTemp := H; 
     f := hTemp MOD 60;  // f is IN [0, 59] 
     hTemp := hTemp DIV 60;  // h is now IN [0,6) 
     VS := V * S; 
     p := V - VS DIV 255;     // p = v * (1 - s) 
     q := V - (VS*f) DIV divisor;   // q = v * (1 - s*f) 
     t := V - (VS*(60 - f)) DIV divisor; // t = v * (1 - s * (1 - f)) 
     CASE hTemp OF 
      0: RESULT := RGBtoRGBTriple(V, t, p); 
      1: RESULT := RGBtoRGBTriple(q, V, p); 
      2: RESULT := RGBtoRGBTriple(p, V, t); 
      3: RESULT := RGBtoRGBTriple(p, q, V); 
      4: RESULT := RGBtoRGBTriple(t, p, V); 
      5: RESULT := RGBtoRGBTriple(V, p, q); 
     ELSE 
      RESULT := RGBtoRGBTriple(0,0,0) // should never happen; 
              // avoid compiler warning 
     END 
    END 
END 

डेल्फी कोड से परिणाम:

मेरे सी # कोड:

public struct HSV 
    { 
     public float h; 
     public float s; 
     public float v; 
    } 


    public void createHsvCircle() 
    { 
     int size = 300; 

     wb = new WriteableBitmap(size, size); 

     wb.Clear(GraphicsUtils.WhiteColor); 

     int radius = size/2; 
     int radiusSquared = radius * radius; 

     int x; 
     int y; 
     int dSquared; 

     HSV hsv; 
     hsv.v = 255F; 

     for (int j = 0; j < size; j++) 
     { 
      y = size - 1 - j - radius; 

      for (int i = 0; i < size; i++) 
      { 
       x = i - radius; 
       dSquared = x * x + y * y; 

       if (dSquared <= radiusSquared) 
       { 
        hsv.s = (float) Math.Round((255 * Math.Sqrt(dSquared))/radius); 

        hsv.h = (float) Math.Round(180 * (1 + Math.Atan2(y, x)/Math.PI)); 

        hsv.h += 90; 
        if (hsv.h > 360) 
        { 
         hsv.h -= 360; 
        } 

        Color color = GraphicsUtils.HsvToRgb(hsv); 

        wb.SetPixel(i, j, color); 
       } 
      } 
     } 

     wb.Invalidate(); 

    } 

    public static Color HsvToRgb(float h, float s, float v) 
    { 
     h = h/360; 
     if (s > 0) 
     { 
      if (h >= 1) 
       h = 0; 
      h = 6 * h; 
      int hueFloor = (int)Math.Floor(h); 
      byte a = (byte)Math.Round(RGB_MAX * v * (1.0 - s)); 
      byte b = (byte)Math.Round(RGB_MAX * v * (1.0 - (s * (h - hueFloor)))); 
      byte c = (byte)Math.Round(RGB_MAX * v * (1.0 - (s * (1.0 - (h - hueFloor))))); 
      byte d = (byte)Math.Round(RGB_MAX * v); 

      switch (hueFloor) 
      { 
       case 0: return Color.FromArgb(RGB_MAX, d, c, a); 
       case 1: return Color.FromArgb(RGB_MAX, b, d, a); 
       case 2: return Color.FromArgb(RGB_MAX, a, d, c); 
       case 3: return Color.FromArgb(RGB_MAX, a, b, d); 
       case 4: return Color.FromArgb(RGB_MAX, c, a, d); 
       case 5: return Color.FromArgb(RGB_MAX, d, a, b); 
       default: return Color.FromArgb(RGB_MAX, 0, 0, 0); 
      } 
     } 
     else 
     { 
      byte d = (byte)(v * RGB_MAX); 
      return Color.FromArgb(255, d, d, d); 
     } 
    } 

    public static Color HsvToRgb(HSV hsv) 
    { 
     return HsvToRgb(hsv.h, hsv.s, hsv.v); 
    }  

मेरे ग # परिणाम:

मैं यह गलत क्या कर रहा हूं?

अग्रिम धन्यवाद।

समाधान

@Aybe से महान जवाब के साथ साथ संपादित, मैं एचएसवी whell से एक काम संस्करण कर सकता है।

यह वह जगह है WP7 एसडीके के लिए काम कोड:

public const double PI = 3.14159265358979323846264338327950288d; 

    public void createHsvCircle(double value = 1.0d) 
    { 
     if (value < 0.0d || value > 1.0d) 
      throw new ArgumentOutOfRangeException("value"); 

     var size = 1024; 

     wb = new WriteableBitmap(size, size); 

     // fill with white. 
     var white = Colors.White; 
     for (int index = 0; index < wb.Pixels.Length; index++) 
     { 
      wb.Pixels[index] = 0xFF << 24 | white.R << 16 | white.G << 8 | white.B; 
     } 

     var cx = size/2; 
     var cy = size/2; 
     var radius = cx; 
     var radiusSquared = radius * radius; 
     for (int i = 0; i < size; i++) 
     { 
      for (int j = 0; j < size; j++) 
      { 
       var x = i - cx; 
       var y = j - cy; 
       var distance = (double)x * x + y * y; 
       if (distance <= radiusSquared) // In circle 
       { 
        var angle = 180.0d * (1 + Math.Atan2(x, y)/PI); 

        // shift 90 degrees so H=0 (red) occurs along "X" axis 
        angle += 90.0d; 
        if (angle > 360.0d) 
        { 
         angle -= 360.0d; 
        } 

        var hue = angle/360.0d; // hue must be into 0 to 1. 
        var saturation = Math.Sqrt(distance)/radius; // saturation must be into 0 to 1. 

        var hsv = new HSV(hue, saturation, value); 
        var rgb = RGB.FromHsv(hsv.H, hsv.S, hsv.V); 

        wb.Pixels[j * size + i] = 0xFF << 24 | rgb.R << 16 | rgb.G << 8 | rgb.B; 
       } 
      } 

     } 
     wb.Invalidate(); 
    } 

    public static RGB FromHsv(double hue, double saturation, double value) 
    { 
     if (hue < 0.0d || hue > 1.0d) 
      throw new ArgumentOutOfRangeException("hue"); 
     if (saturation < 0.0d || saturation > 1.0d) 
      throw new ArgumentOutOfRangeException("saturation"); 
     if (value < 0.0d || value > 1.0d) 
      throw new ArgumentOutOfRangeException("value"); 

     if (saturation == 0.0d) 
     { 
      var b1 = (byte)(value * 255); 
      return new RGB(b1, b1, b1); 
     } 

     double r; 
     double g; 
     double b; 

     var h = hue * 6.0d; 
     if (h == 6.0d) 
     { 
      h = 0.0d; 
     } 

     int i = (int)Math.Floor(h); 

     var v1 = value * (1.0d - saturation); 
     var v2 = value * (1.0d - saturation * (h - i)); 
     var v3 = value * (1.0d - saturation * (1.0d - (h - i))); 

     switch (i) 
     { 
      case 0: 
       r = value; 
       g = v3; 
       b = v1; 
       break; 
      case 1: 
       r = v2; 
       g = value; 
       b = v1; 
       break; 
      case 2: 
       r = v1; 
       g = value; 
       b = v3; 
       break; 
      case 3: 
       r = v1; 
       g = v2; 
       b = value; 
       break; 
      case 4: 
       r = v3; 
       g = v1; 
       b = value; 
       break; 
      default: 
       r = value; 
       g = v1; 
       b = v2; 
       break; 
     } 

     r = r * 255.0d; 
     if (r > 255.0d) 
     { 
      r = 255.0d; 
     } 
     g = g * 255.0d; 
     if (g > 255.0d) 
     { 
      g = 255.0d; 
     } 
     b = b * 255.0d; 
     if (b > 255.0d) 
     { 
      b = 255.0d; 
     } 

     return new RGB((byte)r, (byte)g, (byte)b); 
    } 

और अब, नए परिणाम:

धन्यवाद!

Answer 1

लगभग एक घंटे बिताने के बाद, मैं इस प्रक्रिया में कुछ बातें ...

अब कोड सीखा आपके पास अन्य अल्गोस हैं।

using System; 
using System.Diagnostics; 
using System.Runtime.InteropServices; 
using System.Windows; 
using System.Windows.Media; 
using System.Windows.Media.Imaging; 

namespace ColorWheel 
{ 
    /// <summary> 
    /// Interaction logic for MainWindow.xaml 
    /// </summary> 
    public partial class MainWindow : Window 
    { 
     public MainWindow() 
     { 
      InitializeComponent(); 
     } 

     private void BuildWheel() 
     { 
      var width = 1024; 
      var height = width; 
      var cx = width/2; 
      var cy = height/2; 
      var colors = new int[width*height]; 
      var gray = Colors.Gray.ToBgr32(); 
      for (int index = 0; index < colors.Length; index++) colors[index] = gray; 

      var radius = cx; 
      var radiusSquared = radius*radius; 
      for (int i = 0; i < height; i++) 
      { 
       for (int j = 0; j < width; j++) 
       { 
        var x = j - cx; 
        var y = i - cy; 
        var distanceSquared = (double) x*x + y*y; 
        if (distanceSquared <= radiusSquared) // In circle 
        { 
         var h = Math.Atan2(x, y).ToDegrees() + 180.0d; // Angle 
         var s = 1.0d; 
         var l = (1.0d - ((1.0d/radiusSquared)*distanceSquared)); // 1 - (distance normalized) 
         var hsl = new HSL((float) h, (float) s, (float) l); 
         var rgb = RGB.FromHsl(hsl.H, hsl.S, hsl.L); 
         colors[i*width + j] = rgb.R << 16 | rgb.G << 8 | rgb.B; 
        } 
       } 
      } 
      var bitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgr32, null); 
      bitmap.WritePixels(new Int32Rect(0, 0, width, height), colors, width*4, 0); 
      image.Source = bitmap; 
     } 

     private void Window_Loaded(object sender, RoutedEventArgs e) 
     { 
      BuildWheel(); 
     } 
    } 

    public static class Helpers 
    { 
     public static double ToDegrees(this double radians) 
     { 
      return radians*57.2957795130823; // radians * (180.0d/Math.PI) 
     } 

     public static double ToRadians(this double degrees) 
     { 
      return degrees*0.0174532925199433; // degrees * (Math.PI/180.0d) 
     } 
    } 

    public static class ColorExtensions 
    { 
     public static Color FromBgr32(this Int32 color) 
     { 
      return Color.FromRgb((byte) ((color & 0xFF0000) >> 16), (byte) ((color & 0xFF00) >> 8), (byte) (color & 0xFF)); 
     } 

     public static int ToBgr32(this Color color) 
     { 
      return color.R << 16 | color.G << 8 | color.B; 
     } 
    } 

    /// <summary> 
    /// Represents a color in an HSL space. 
    /// </summary> 
    [StructLayout(LayoutKind.Sequential)] 
    public struct HSL 
    { 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly double _h; 

     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly double _s; 

     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly double _l; 

     /// <summary> 
     /// Returns the fully qualified type name of this instance. 
     /// </summary> 
     /// <returns> A <see cref="T:System.String" /> containing a fully qualified type name. </returns> 
     /// <filterpriority>2</filterpriority> 
     public override string ToString() 
     { 
      return string.Format("H: {0}, S: {1}, L: {2}", _h, _s, _l); 
     } 

     /// <summary> 
     /// Create a new instance of <see cref="HSL" /> . 
     /// </summary> 
     /// <param name="h"> Value of <see cref="H" /> component. </param> 
     /// <param name="s"> Value of <see cref="S" /> component. </param> 
     /// <param name="l"> Value of <see cref="L" /> component. </param> 
     public HSL(double h, double s, double l) 
     { 
      _h = h; 
      _s = s; 
      _l = l; 
     } 

     /// <summary> 
     /// Gets the value of the hue component. 
     /// </summary> 
     public double H 
     { 
      get { return _h; } 
     } 

     /// <summary> 
     /// Gets the value of the saturation component. 
     /// </summary> 
     public double S 
     { 
      get { return _s; } 
     } 

     /// <summary> 
     /// Gets the value of the lightness component. 
     /// </summary> 
     public double L 
     { 
      get { return _l; } 
     } 

     public override bool Equals(object obj) 
     { 
      if (ReferenceEquals(null, obj)) return false; 
      if (obj.GetType() != typeof (HSL)) return false; 
      return Equals((HSL) obj); 
     } 

     public bool Equals(HSL other) 
     { 
      return other._h.Equals(_h) && other._l.Equals(_l) && 
        other._s.Equals(_s); 
     } 

     /// <summary> 
     /// Create a new instance of <see cref="HSL" /> , from RGB values. 
     /// </summary> 
     /// <param name="red"> Value of the red component. </param> 
     /// <param name="green"> Value of the green component. </param> 
     /// <param name="blue"> Value of the blue component. </param> 
     /// <returns> <see cref="HSL" /> instance created. </returns> 
     public static HSL FromRGB(byte red, byte green, byte blue) 
     { 
      var r1 = red/255.0d; 
      var g1 = green/255.0d; 
      var b1 = blue/255.0d; 

      var min = Math.Min(r1, Math.Min(g1, b1)); 
      var max = Math.Max(r1, Math.Max(g1, b1)); 

      var l = (max + min)/2.0d; 

      var s = 0.0d; 
      var h = 0.0d; 
      if (min == max) 
      { 
       h = 0.0d; 
       s = 0.0d; 
      } 
      else 
      { 
       if (l < 0.5d) 
       { 
        s = (max - min)/(max + min); 
       } 
       else if (l >= 0.5d) 
       { 
        s = (max - min)/(2.0d - max - min); 
       } 

       if (r1 == max) 
       { 
        h = (g1 - b1)/(max - min); 
       } 
       else if (g1 == max) 
       { 
        h = 2.0d + (b1 - r1)/(max - min); 
       } 
       else if (b1 == max) 
       { 
        h = 4.0d + (r1 - g1)/(max - min); 
       } 
      } 

      h *= 60.0d; 

      if (h < 0.0d) 
       h += 360.0d; 

      return new HSL(h, s, l); 
     } 

     /// <summary> 
     /// Returns the hash code for this instance. 
     /// </summary> 
     /// <returns> A 32-bit signed integer that is the hash code for this instance. </returns> 
     /// <filterpriority>2</filterpriority> 
     public override int GetHashCode() 
     { 
      unchecked 
      { 
       var result = _h.GetHashCode(); 
       result = (result*397)^_l.GetHashCode(); 
       result = (result*397)^_s.GetHashCode(); 
       return result; 
      } 
     } 


     public static BitmapSource GetHslPalette(int width = 360, int height = 100) 
     { 
      // Creates an HSL palette image like in Photoshop, etc ... 
      var pixels = new int[width*height]; 
      const double saturation = 1.0d; 
      for (var y = 0; y < height; y++) 
      { 
       for (var x = 0; x < width; x++) 
       { 
        var hue = (1.0d/width)*x*360.0d; 
        var lightness = 1.0d - ((1.0f/height)*y); 
        var rgb = RGB.FromHsl(hue, saturation, lightness); 
        pixels[y*width + x] = 0xFF << 24 | rgb.R << 16 | rgb.G << 8 | rgb.B; 
       } 
      } 
      return BitmapSource.Create(width, height, 96, 96, PixelFormats.Pbgra32, null, pixels, width*4); 
     } 

     public static bool operator ==(HSL left, HSL right) 
     { 
      return left.Equals(right); 
     } 

     public static bool operator !=(HSL left, HSL right) 
     { 
      return !left.Equals(right); 
     } 
    } 

    /// <summary> 
    /// Represents a color in an RGB space. 
    /// </summary> 
    [StructLayout(LayoutKind.Sequential)] 
    public struct RGB 
    { 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly byte _r; 

     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly byte _g; 

     [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly byte _b; 

     /// <summary> 
     /// Create a new instance of <see cref="RGB" /> . 
     /// </summary> 
     /// <param name="r"> Value of red component. </param> 
     /// <param name="g"> Value of green component. </param> 
     /// <param name="b"> Value of blue component. </param> 
     public RGB(byte r, byte g, byte b) 
     { 
      _r = r; 
      _g = g; 
      _b = b; 
     } 

     /// <summary> 
     /// Returns the fully qualified type name of this instance. 
     /// </summary> 
     /// <returns> A <see cref="T:System.String" /> containing a fully qualified type name. </returns> 
     /// <filterpriority>2</filterpriority> 
     public override string ToString() 
     { 
      return string.Format("R: {0}, G: {1}, B: {2}", _r, _g, _b); 
     } 

     /// <summary> 
     /// Gets the value of the red component. 
     /// </summary> 
     public byte R 
     { 
      get { return _r; } 
     } 

     /// <summary> 
     /// Gets the value of the green component. 
     /// </summary> 
     public byte G 
     { 
      get { return _g; } 
     } 

     /// <summary> 
     /// Gets the value of the blue component. 
     /// </summary> 
     public byte B 
     { 
      get { return _b; } 
     } 

     public override bool Equals(object obj) 
     { 
      if (ReferenceEquals(null, obj)) return false; 
      if (obj.GetType() != typeof (RGB)) return false; 
      return Equals((RGB) obj); 
     } 

     public bool Equals(RGB other) 
     { 
      return other._b == _b && other._g == _g && other._r == _r; 
     } 

     /// <summary> 
     /// Create a new instance of <see cref="RGB" /> , from HSL values. 
     /// </summary> 
     /// <param name="hue"> Hue, from 0.0 to 360.0. </param> 
     /// <param name="saturation"> Saturation, from 0.0 to 1.0. </param> 
     /// <param name="lightness"> Lightness, from 0.0 to 1.0. </param> 
     /// <returns> <see cref="RGB" /> instance created. </returns> 
     public static RGB FromHsl(double hue, double saturation, double lightness) 
     { 
      if (hue < 0.0d || hue > 360.0d) throw new ArgumentOutOfRangeException("hue"); 
      if (saturation < 0.0d || saturation > 1.0d) throw new ArgumentOutOfRangeException("saturation"); 
      if (lightness < 0.0d || lightness > 1.0d) throw new ArgumentOutOfRangeException("lightness"); 

      if (saturation == 0.0d) 
      { 
       var b1 = (byte) (lightness*255); 
       return new RGB(b1, b1, b1); 
      } 

      var t2 = 0.0d; 

      if (lightness < 0.5d) 
       t2 = lightness*(1.0d + saturation); 
      else if (lightness >= 0.5d) 
       t2 = lightness + saturation - lightness*saturation; 

      var t1 = 2.0d*lightness - t2; 

      var h = hue/360.0d; 

      var tr = h + 1.0d/3.0d; 
      var tg = h; 
      var tb = h - 1.0d/3.0d; 

      tr = tr < 0.0d ? tr + 1.0d : tr > 1.0d ? tr - 1.0d : tr; 
      tg = tg < 0.0d ? tg + 1.0d : tg > 1.0d ? tg - 1.0d : tg; 
      tb = tb < 0.0d ? tb + 1.0d : tb > 1.0d ? tb - 1.0d : tb; 

      double r; 
      if (6.0d*tr < 1.0d) 
       r = t1 + (t2 - t1)*6.0d*tr; 
      else if (2.0d*tr < 1.0d) 
       r = t2; 
      else if (3.0d*tr < 2.0d) 
       r = t1 + (t2 - t1)*((2.0d/3.0d) - tr)*6.0d; 
      else 
       r = t1; 

      double g; 
      if (6.0d*tg < 1.0d) 
       g = t1 + (t2 - t1)*6.0d*tg; 
      else if (2.0d*tg < 1.0d) 
       g = t2; 
      else if (3.0d*tg < 2.0d) 
       g = t1 + (t2 - t1)*((2.0d/3.0d) - tg)*6.0d; 
      else 
       g = t1; 

      double b; 
      if (6.0d*tb < 1.0d) 
       b = t1 + (t2 - t1)*6.0d*tb; 
      else if (2.0d*tb < 1.0d) 
       b = t2; 
      else if (3.0d*tb < 2.0d) 
       b = t1 + (t2 - t1)*((2.0d/3.0d) - tb)*6.0d; 
      else 
       b = t1; 

      return new RGB((byte) (r*255), (byte) (g*255), (byte) (b*255)); 
     } 

     /// <summary> 
     /// Returns the hash code for this instance. 
     /// </summary> 
     /// <returns> A 32-bit signed integer that is the hash code for this instance. </returns> 
     /// <filterpriority>2</filterpriority> 
     public override int GetHashCode() 
     { 
      unchecked 
      { 
       var result = _b.GetHashCode(); 
       result = (result*397)^_g.GetHashCode(); 
       result = (result*397)^_r.GetHashCode(); 
       return result; 
      } 
     } 

     public static bool operator ==(RGB left, RGB right) 
     { 
      return left.Equals(right); 
     } 

     public static bool operator !=(RGB left, RGB right) 
     { 
      return !left.Equals(right); 
     } 
    } 
} 

Answer 2

डिफ़ॉल्ट रूप से WP7 डिवाइस 16-बिट पर बिट-गहराई नहीं है? मेरे Omnia 7 पर यह है। एक रजिस्ट्री सेटिंग है जो इस पैरामीटर को नियंत्रित करती है लेकिन यह सभी फोन पर उपलब्ध नहीं हो सकती है, आपको इसके बजाय 24-बिट से 16-बिट तक अपने रंगों को डालना चाहिए, यह तब सभी फोन पर उपलब्ध होगा। मेरा सुझाव है कि आपको Microsoft.Xna.Framework.Graphics.PackedVector पर नज़र डालें, ऐसे निर्माता हैं जैसे बीजीआर 565 जो एक इनपुट के रूप में तैरता है। और आपके सभी रंग रूपांतरण आवश्यकताओं के लिए: http://www.easyrgb.com/, रंग रिक्त स्थान के बीच कनवर्ट करने के लिए बहुत सारे एल्गोरिदम हैं। (किसी भी आकार के लिए काम करता है)

यह एचएसएल है, लेकिन मैं आप वह URL यहां दिया: