Esempio n. 1
0
        public static unsafe void ToRgb24(Lab24 *from, Rgb24 *to, int length = 1)
        {
            if (length < 1)
            {
                return;
            }

            // 使用 OpenCV 中的算法实现
            const float coeff0 = 0.39215686274509809f;
            const float coeff1 = 0.0f;
            const float coeff2 = 1.0f;
            const float coeff3 = (-128.0f);
            const float coeff4 = 1.0f;
            const float coeff5 = (-128.0f);

            Lab24 *end = from + length;
            float  x, y, z, l, a, b;
            int    blue, green, red;

            while (from != end)
            {
                l = from->L * coeff0 + coeff1;
                a = from->A * coeff2 + coeff3;
                b = from->B * coeff4 + coeff5;

                l = (l + labLShift_32f) * (1.0f / labLScale_32f);
                x = (l + a * 0.002f);
                z = (l - b * 0.005f);

                y = l * l * l;
                x = x * x * x;
                z = z * z * z;

                blue  = (int)((x * labBx_32f + y * labBy_32f + z * labBz_32f) * 255 + 0.5);
                green = (int)((x * labGx_32f + y * labGy_32f + z * labGz_32f) * 255 + 0.5);
                red   = (int)((x * labRx_32f + y * labRy_32f + z * labRz_32f) * 255 + 0.5);

                red   = red < 0 ? 0 : red > 255 ? 255 : red;
                green = green < 0 ? 0 : green > 255 ? 255 : green;
                blue  = blue < 0 ? 0 : blue > 255 ? 255 : blue;

                to->Red   = (byte)red;
                to->Green = (byte)green;
                to->Blue  = (byte)blue;

                from++;
                to++;
            }
        }
Esempio n. 2
0
        public static unsafe void ToRgb24(Argb32 *from, Rgb24 *to, int length = 1)
        {
            if (length < 1)
            {
                return;
            }
            Argb32 *end = from + length;

            while (from != end)
            {
                *to = *((Rgb24 *)from);
                from++;
                to++;
            }
        }
Esempio n. 3
0
        public static unsafe void ToByte(Rgb24 *from, byte *to, int length = 1)
        {
            if (length < 1)
            {
                return;
            }

            Rgb24 *end = from + length;

            while (from != end)
            {
                *to = (Byte)(from->Blue * 0.114 + from->Green * 0.587 + from->Red * 0.299);
                from++;
                to++;
            }
        }
Esempio n. 4
0
 // [Benchmark]
 public void Rgb24_Scalar_PerElement_Pinned()
 {
     fixed(byte *r = &this.rBuf[0])
     fixed(byte *g     = &this.gBuf[0])
     fixed(byte *b     = &this.bBuf[0])
     fixed(Rgb24 * rgb = &this.rgbBuf[0])
     {
         for (int i = 0; i < this.Count; i++)
         {
             Rgb24 *d = rgb + i;
             d->R = r[i];
             d->G = g[i];
             d->B = b[i];
         }
     }
 }
Esempio n. 5
0
        public unsafe ImageInt32 ToGrayscaleImageInt32(double rCoeff, double gCoeff, double bCoeff)
        {
            ImageInt32 img = new ImageInt32(this.Width, this.Height);
            Rgb24 *    p   = Start;
            Int32 *    to  = img.Start;
            Rgb24 *    end = p + Length;

            if (Length < 1024)
            {
                while (p != end)
                {
                    *to = (Byte)(p->Red * rCoeff + p->Green * gCoeff + p->Blue * bCoeff);
                    p++;
                    to++;
                }
            }
            else
            {
                int *bCache = stackalloc int[256];
                int *gCache = stackalloc int[256];
                int *rCache = stackalloc int[256];

                const int shift  = 1 << 10;
                int       rShift = (int)(rCoeff * shift);
                int       gShift = (int)(gCoeff * shift);
                int       bShift = shift - rShift - gShift;

                int r = 0, g = 0, b = 0;
                for (int i = 0; i < 256; i++)
                {
                    bCache[i] = b;
                    gCache[i] = g;
                    rCache[i] = r;
                    b        += bShift;
                    g        += gShift;
                    r        += rShift;
                }

                while (p != end)
                {
                    *to = (Byte)((bCache[p->Red] + gCache[p->Green] + rCache[p->Red]) >> 10);
                    p++;
                    to++;
                }
            }
            return(img);
        }
        private static unsafe float[] Load(Image <Rgb24> image)
        {
            int resolution = image.Height * image.Width;

            float[] sample = new float[resolution * 3];
            fixed(Rgb24 *p0 = &image.DangerousGetPinnableReferenceToPixelBuffer())
            fixed(float *psample = sample)
            {
                for (int i = 0; i < resolution; i++)
                {
                    Rgb24 *pxy = p0 + i;
                    psample[i] = pxy->R / 255f;
                    psample[i + resolution]     = pxy->G / 255f;
                    psample[i + 2 * resolution] = pxy->B / 255f;
                }
            }
            return(sample);
        }
Esempio n. 7
0
        public static unsafe void ToArgb32(Rgb24 *from, Argb32 *to, int length = 1)
        {
            if (length < 1)
            {
                return;
            }

            Rgb24 *end = from + length;

            while (from != end)
            {
                to->Blue  = from->Blue;
                to->Green = from->Green;
                to->Red   = from->Red;
                to->Alpha = 255;
                from++;
                to++;
            }
        }
Esempio n. 8
0
        public static unsafe void ToRgb24(byte *from, Rgb24 *to, int length = 1)
        {
            if (length < 1)
            {
                return;
            }

            Byte *end = from + length;

            while (from != end)
            {
                Byte val = *from;
                to->Blue  = val;
                to->Green = val;
                to->Red   = val;
                from++;
                to++;
            }
        }
Esempio n. 9
0
        public static unsafe void ToLab24(Rgb24 *from, Lab24 *to, int length = 1)
        {
            // 使用 OpenCV 中的算法实现

            if (length < 1)
            {
                return;
            }

            Rgb24 *end = from + length;

            int  x, y, z;
            int  l, a, b;
            bool flag;

            while (from != end)
            {
                Byte red   = from->Red;
                Byte green = from->Green;
                Byte blue  = from->Blue;

                x = blue * labXb + green * labXg + red * labXr;
                y = blue * labYb + green * labYg + red * labYr;
                z = blue * labZb + green * labZg + red * labZr;

                flag = x > labT;

                x = (((x) + (1 << ((lab_shift) - 1))) >> (lab_shift));

                if (flag)
                {
                    x = icvLabCubeRootTab[x];
                }
                else
                {
                    x = (((x * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));
                }

                flag = z > labT;
                z    = (((z) + (1 << ((lab_shift) - 1))) >> (lab_shift));

                if (flag == true)
                {
                    z = icvLabCubeRootTab[z];
                }
                else
                {
                    z = (((z * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));
                }

                flag = y > labT;
                y    = (((y) + (1 << ((lab_shift) - 1))) >> (lab_shift));

                if (flag == true)
                {
                    y = icvLabCubeRootTab[y];
                    l = (((y * labLScale - labLShift) + (1 << ((2 * lab_shift) - 1))) >> (2 * lab_shift));
                }
                else
                {
                    l = (((y * labLScale2) + (1 << ((lab_shift) - 1))) >> (lab_shift));
                    y = (((y * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));
                }

                a = (((500 * (x - y)) + (1 << ((lab_shift) - 1))) >> (lab_shift)) + 129;
                b = (((200 * (y - z)) + (1 << ((lab_shift) - 1))) >> (lab_shift)) + 128;

                l = l > 255 ? 255 : l < 0 ? 0 : l;
                a = a > 255 ? 255 : a < 0 ? 0 : a;
                b = b > 255 ? 255 : b < 0 ? 0 : b;

                to->L = (byte)l;
                to->A = (byte)a;
                to->B = (byte)b;

                from++;
                to++;
            }
        }
Esempio n. 10
0
 public unsafe void Copy(Rgb24 *from, void *to, int length)
 {
     UnmanagedImageConverter.ToArgb32(from, (Argb32 *)to, length);
 }
Esempio n. 11
0
 public unsafe void Copy(Rgb24 *from, void *to, int length)
 {
     UnmanagedImageConverter.Copy((byte *)from, (byte *)to, 3 * length);
 }
Esempio n. 12
0
 public unsafe void Copy(Rgb24 *from, void *to, int length)
 {
     UnmanagedImageConverter.ToLab24(from, (Lab24 *)to, length);
 }