Asp.net में एचएसएल का उपयोग कैसे करें

.NET में एचएसएल रंगों के साथ काम करने के लिए किस उपकरण का उपयोग किया जाता है?

0
जोड़ा संपादित
विचारों: 2

3 उत्तर

कलर स्ट्रक्चर तीन विधियों को प्रदान करता है: GetHue, GetSaturation और GetBrightness।

बॉब पॉवेल ने एक इस पर दिलचस्प टुकड़ा लिखा है कई साल पहले।

विचित्र ऐतिहासिक नोट - "एचएसएल" (और संबंधित "एचएसवी") 70 के दशक में जेरोक्स के पालो अल्टो रिसर्च सेंटर (पीआरसी) से उत्पन्न कई चीजों में से एक है, एल्वी रे स्मिथ

0
जोड़ा
धन्यवाद डेरेक, मैंने इसे archive.org की आलेख की प्रतिलिपि के लिंक के साथ अपडेट किया है।
जोड़ा लेखक Leon Bambrick, स्रोत
बॉब पॉवेल का कोड वास्तव में आसान है। मैंने तब से अपनी सामग्री में इसका इस्तेमाल किया है और इसे System.Windows.Media.Color क्लास पर एक्सटेंशन विधियों को प्रदान करने के लिए परिवर्तित कर दिया है।
जोड़ा लेखक Mal Ross, स्रोत
bobpowell.net/RGBHSB.htm का लिंक एक मृत लिंक है
जोड़ा लेखक Derek Tomes, स्रोत

गुप्त जीक के जवाब के अलावा, एचएसएल मानों (या इसके विपरीत) से रंग प्राप्त करने के लिए, आप इन देशी फ़ंक्शन कॉल (विज़ुअल बेसिक में नमूना कोड) का भी उपयोग कर सकते हैं:

Public Declare Sub ColorRGBToHLS Lib "shlwapi.dll" _
                                    (ByVal clrRGB As UInteger, _
                                     ByRef pwHue As Short, _
                                     ByRef pwLuminance As Short, _
                                     ByRef pwSaturation As Short)
Public Declare Function ColorHLSToRGB Lib "shlwapi.dll" _
                                        (ByVal wHue As Short, _
                                         ByVal wLuminance As Short, _
                                         ByVal wSaturation As Short) As UInteger

(कलर तर्क / परिणाम पास / प्राप्त करते समय ColorTranslator.ToWin32 और ColorTranslator.FromWin32 का उपयोग करके)

0
जोड़ा

यह ColorRGB क्लास System.Drawing.Color से और उसके निहित रूपांतरण के साथ एचएसएल को प्राप्त करने और सेट करने के तरीके प्रदान करता है। यह GeekMonkey.com से एक उत्कृष्ट उदाहरण पर आधारित है।

using System;
using System.Drawing;

namespace RMA.Drawing
{
  public class ColorRGB
  {
    public byte R;
    public byte G;
    public byte B;
    public byte A;

    public ColorRGB()
    {
      R = 255;
      G = 255;
      B = 255;
      A = 255;
    }

    public ColorRGB(Color value)
    {
      this.R = value.R;
      this.G = value.G;
      this.B = value.B;
      this.A = value.A;
    }

    public static implicit operator Color(ColorRGB rgb)
    {
      Color c = Color.FromArgb(rgb.A, rgb.R, rgb.G, rgb.B);
      return c;
    }

    public static explicit operator ColorRGB(Color c)
    {
      return new ColorRGB(c);
    }

    // Given H,S,L in range of 0-1
    // Returns a Color (RGB struct) in range of 0-255
    public static ColorRGB FromHSL(double H, double S, double L)
    {
      return FromHSLA(H, S, L, 1.0);
    }

    // Given H,S,L,A in range of 0-1
    // Returns a Color (RGB struct) in range of 0-255
    public static ColorRGB FromHSLA(double H, double S, double L, double A)
    {
      double v;
      double r, g, b;

      if (A > 1.0)
        A = 1.0;

      r = L;   // default to gray
      g = L;
      b = L;
      v = (L <= 0.5) ? (L * (1.0 + S)) : (L + S - L * S);

      if (v > 0)
      {
        double m;
        double sv;
        int sextant;
        double fract, vsf, mid1, mid2;

        m = L + L - v;
        sv = (v - m) / v;
        H *= 6.0;
        sextant = (int)H;
        fract = H - sextant;
        vsf = v * sv * fract;
        mid1 = m + vsf;
        mid2 = v - vsf;

        switch (sextant)
        {
          case 0:
            r = v;
            g = mid1;
            b = m;
            break;

          case 1:
            r = mid2;
            g = v;
            b = m;
            break;

          case 2:
            r = m;
            g = v;
            b = mid1;
            break;

          case 3:
            r = m;
            g = mid2;
            b = v;
            break;

          case 4:
            r = mid1;
            g = m;
            b = v;
            break;

          case 5:
            r = v;
            g = m;
            b = mid2;
            break;
        }
      }

      ColorRGB rgb = new ColorRGB();
      rgb.R = Convert.ToByte(r * 255.0f);
      rgb.G = Convert.ToByte(g * 255.0f);
      rgb.B = Convert.ToByte(b * 255.0f);
      rgb.A = Convert.ToByte(A * 255.0f);
      return rgb;
    }

    // Hue in range from 0.0 to 1.0
    public float H
    {
      get
      {
        // Use System.Drawing.Color.GetHue, but divide by 360.0F 
        // because System.Drawing.Color returns hue in degrees (0 - 360)
        // rather than a number between 0 and 1.
        return ((Color)this).GetHue() / 360.0F;
      }
    }

    // Saturation in range 0.0 - 1.0
    public float S
    {
      get
      {
        return ((Color)this).GetSaturation();
      }
    }

    // Lightness in range 0.0 - 1.0
    public float L
    {
      get
      {
        return ((Color)this).GetBrightness();
      }
    }
  }
}
0
जोड़ा
नहीं, आपने अल्फा क्लैंपिंग तय की है। समस्या यह है कि ह्यू 1.0 हो सकता है, जो 6 का एक सेक्स्टेंट वैल्यू देता है, जिसे case कथन में प्रबंधित नहीं किया जाता है।
जोड़ा लेखक Glenn Slayden, स्रोत
आपका FromHSLA एच = 1.0 के मामले को संभाल नहीं करता है।
जोड़ा लेखक Don Reba, स्रोत
मैंने कोड अपडेट किया; स्विच कथन अब एच = 1.0 संभालता है
जोड़ा लेखक Paul d'Aoust, स्रोत