Exemple #1
0
        /// <summary>
        /// Process frame.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <param name="bmSrc">Bitmap data</param>
        private unsafe double ProcessFrameWithFilter(BitmapData bmData, BitmapData bmSrc)
        {
            byte *dst = (byte *)bmData.Scan0.ToPointer();
            byte *src = (byte *)bmSrc.Scan0.ToPointer();
            int   width = bmData.Width, height = bmData.Height;

            double variance = 0.0;

            for (int x = 0; x < width; x++)
            {
                int y, k;

                for (y = 0; y < height; y++, dst += 4, src += 4)
                {
                    for (k = 0; k < 3; k++)
                    {
                        var difference = Math.Abs(dst[k] - src[k]);
                        dst[k] = Maths.Byte(difference);
                    }

                    var summary = RGB.Average(dst[2], dst[1], dst[0]);

                    if (summary > Threshold)
                    {
                        variance++;
                    }
                }
            }
            ;

            return(variance / (width * height));
        }
Exemple #2
0
 private Optimizer(RGB[] pixels, int limit, int error)
 {
     _pixels    = pixels;
     _limit     = limit;
     _baseColor = RGB.Average(pixels).Unscale(limit);
     _bestSln   = new Solution {
         Error = error
     };
 }
Exemple #3
0
 Optimizer(RGB[] pixels, int limit, int error)
 {
     this.pixels = pixels;
     this.limit  = limit;
     baseColor   = RGB.Average(pixels).Unscale(limit);
     best_soln   = new Solution {
         error = error
     };
 }
Exemple #4
0
        /// <summary>
        /// Apply filter.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <param name="bmSrc">Bitmap data</param>
        public unsafe void Apply(BitmapData bmData, BitmapData bmSrc)
        {
            byte *p = (byte *)bmData.Scan0.ToPointer();
            byte *pSrc = (byte *)bmSrc.Scan0.ToPointer();
            int   y, x, width = bmData.Width, height = bmData.Height;

            for (x = 0; x < width; x++)
            {
                for (y = 0; y < height; y++, p += 4, pSrc += 4)
                {
                    p[3] = (byte)RGB.Average(pSrc[2], pSrc[1], pSrc[0]);
                }
            }
            return;
        }
Exemple #5
0
        /// <summary>
        /// Apply filter.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <param name="bmMax">Bitmap data</param>
        /// <param name="bmMin">Bitmap data</param>
        private unsafe void ApplyGrayscale(BitmapData bmData, BitmapData bmMax, BitmapData bmMin)
        {
            byte *p = (byte *)bmData.Scan0.ToPointer();
            byte *pMax = (byte *)bmMax.Scan0.ToPointer();
            byte *pMin = (byte *)bmMin.Scan0.ToPointer();
            int   width = bmData.Width, height = bmData.Height, stride = bmData.Stride;

            float required = 1.0f - this.contrast;

            Parallel.For(0, height, j =>
            {
                int i, k, k1, k2, v, jstride = j * stride;
                float mag, max, min;
                float num1, num2, num3;

                for (i = 0; i < width; i++)
                {
                    k = jstride + i * 4; k1 = k + 1; k2 = k + 2;

                    // Local function:
                    v = k;

                    mag = RGB.Average(p[v], p[v + 1], p[v + 2]) / 255.0f;
                    max = RGB.Average(pMax[v], pMax[v + 1], pMax[v + 2]) / 255.0f;
                    min = RGB.Average(pMin[v], pMin[v + 1], pMin[v + 2]) / 255.0f;

                    num1 = max - min;

                    if (num1 < required)
                    {
                        num2 = min + (required - num1) * min / (num1 - 1f);
                        min  = Maths.Float(num2);
                        max  = Maths.Float(num2 + required);
                    }

                    num1 = max - min;
                    num3 = mag - min;

                    if (num1 > 0)
                    {
                        p[v] = p[v + 1] = p[v + 2] = Maths.Byte(255 * num3 / num1);
                    }
                    // end local function.
                }
            }
                         );
        }
Exemple #6
0
        /// <summary>
        /// Gets a histogram of the image.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <returns>Array</returns>
        public unsafe static int[] Histogram(this BitmapData bmData)
        {
            int[] rgb = new int[256];
            byte *p = (byte *)bmData.Scan0.ToPointer();
            int   y, x, width = bmData.Width, height = bmData.Height;
            byte  brightness;

            for (y = 0; y < height; y++)
            {
                for (x = 0; x < width; x++, p += 4)
                {
                    brightness = (byte)RGB.Average(p[2], p[1], p[0]);
                    rgb[brightness]++;
                }
            }
            return(rgb);
        }
Exemple #7
0
        /// <summary>
        /// Apply filter.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        public unsafe void Apply(BitmapData bmData)
        {
            byte *p = (byte *)bmData.Scan0.ToPointer();
            int   width = bmData.Width, height = bmData.Height;
            int   stride = bmData.Stride;

            // filter color
            float rf = color.R / 255.0f;
            float gf = color.G / 255.0f;
            float bf = color.B / 255.0f;

            // do job
            Parallel.For(0, height, y =>
            {
                // bitmap color
                float lm;
                float rb;
                float gb;
                float bb;

                int x, ystride, k;

                ystride = y * stride;

                for (x = 0; x < width; x++)
                {
                    k = ystride + x * 4;

                    // luma
                    lm = RGB.Average(p[k + 2], p[k + 1], p[k]) / 255.0f;

                    // blending
                    rb = this.blendf(lm, rf) * 255.0f;
                    gb = this.blendf(lm, gf) * 255.0f;
                    bb = this.blendf(lm, bf) * 255.0f;

                    // recording
                    p[k + 2] = Maths.Byte(rb * s + p[k + 2] * (1.0f - s));
                    p[k + 1] = Maths.Byte(gb * s + p[k + 1] * (1.0f - s));
                    p[k]     = Maths.Byte(bb * s + p[k] * (1.0f - s));
                }
            });

            return;
        }
Exemple #8
0
        /// <summary>
        /// Converts Bitmap to averaged channel value matrix.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <returns>Matrix</returns>
        public unsafe static float[,] ToGrayscale(this BitmapData bmData)
        {
            int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;

            float[,] rgb = new float[height, width];
            byte *p = (byte *)bmData.Scan0.ToPointer();

            Parallel.For(0, height, j =>
            {
                int i, k, jstride = j * stride;

                for (i = 0; i < width; i++)
                {
                    k         = jstride + i * 4;
                    rgb[j, i] = RGB.Average(p[k + 2], p[k + 1], p[k]) / 255.0f;
                }
            });

            return(rgb);
        }
Exemple #9
0
        /// <summary>
        /// Converts Bitmap into unshort matrix.
        /// </summary>
        /// <param name="depth">Image</param>
        /// <returns>Bitmap</returns>
        public unsafe static ushort[,] FromBitmap(this Bitmap depth)
        {
            var bmData = depth.Lock32bpp();
            var width  = bmData.Width;
            var height = bmData.Height;
            var stride = bmData.Stride;
            var src    = (byte *)bmData.Scan0.ToPointer();
            var output = new ushort[height, width];

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    var k = x * 3 + y * stride;
                    output[y, x] = (ushort)RGB.Average(src[k + 0], src[k + 1], src[k + 2]);
                }
            }

            depth.Unlock(bmData);
            return(output);
        }
Exemple #10
0
        /// <summary>
        /// Apply filter.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        /// <param name="bmSrc">Bitmap data</param>
        private unsafe void ApplyGrayscale(BitmapData bmData, BitmapData bmSrc)
        {
            byte *p = (byte *)bmData.Scan0.ToPointer(), pSrc = (byte *)bmSrc.Scan0.ToPointer();
            int   width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
            float length = values.GetLength(0) - 1;

            Parallel.For(0, height, j =>
            {
                int i, k, lumax, lumay, jstride = j * stride;

                for (i = 0; i < width; i++)
                {
                    k = jstride + i * 4;

                    lumax = RGB.Average(p[k + 2], p[k + 1], p[k]);
                    lumay = RGB.Average(pSrc[k + 2], pSrc[k + 1], pSrc[k]);

                    p[k + 2] = p[k + 1] = p[k] = Maths.Byte(this.values[lumax, lumay] * length);
                }
            });

            return;
        }
Exemple #11
0
        /// <summary>
        /// Apply filter.
        /// </summary>
        /// <param name="bmData">Bitmap data</param>
        private unsafe void ApplyGrayscale(BitmapData bmData)
        {
            byte *p = (byte *)bmData.Scan0.ToPointer();
            int   width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
            float length = values.Length - 1;

            Parallel.For(0, height, y =>
            {
                int x, ystride, k;
                int luma;

                ystride = y * stride;

                for (x = 0; x < width; x++)
                {
                    k        = ystride + x * 4;
                    luma     = RGB.Average(p[k + 2], p[k + 1], p[k]);
                    p[k + 2] = p[k + 1] = p[k] = Maths.Byte(values[luma] * length);
                }
            }
                         );

            return;
        }
        /// <summary>
        /// Render all UI.
        /// </summary>
        private void InitializeUI()
        {
            if (PanelEntity.Attributes.ContainsKey("friendly_name"))
            {
                TextBlock textBlock = FindName("DeviceText") as TextBlock;
                textBlock.Text = PanelEntity.Name().ToUpper();
            }

            // For the group panel, average the color of children entities together
            if (ChildrenEntities != null)
            {
                // Set the color adjustment sliders and color wheel by blending the average
                // color for each. Include entities which are in the On state only.
                IEnumerable <Entity> onEntities = ChildrenEntities.Where(x => string.Equals(x.State, "on", StringComparison.InvariantCultureIgnoreCase));

                if (onEntities.Any())
                {
                    // Average the brightness
                    IEnumerable <Entity> brightnessEntities = onEntities.Where(x => x.Attributes.ContainsKey("brightness"));
                    if (brightnessEntities.Any())
                    {
                        double averageBrightness = onEntities.Select(x => Convert.ToDouble(x.Attributes["brightness"])).Cast <double>().Average();
                        UpdateBrightnessControl(averageBrightness);
                    }
                    else
                    {
                        Ellipse ellipse = this.FindName("BrightnessCircle") as Ellipse;
                        ellipse.Visibility = Visibility.Collapsed;
                    }

                    // Average the color temperature
                    IEnumerable <Entity> colorTempEntities = onEntities.Where(x => x.Attributes.ContainsKey("color_temp"));
                    if (colorTempEntities.Any())
                    {
                        double averageColorTemperature = colorTempEntities.Select(x => Convert.ToDouble(x.Attributes["color_temp"])).Cast <double>().Average();

                        UpdateColorTemperatureControl(Convert.ToInt32(averageColorTemperature));

                        ShowColorTemperatureCircle(Visibility.Visible);
                    }
                    else
                    {
                        ShowColorTemperatureCircle(Visibility.Collapsed);
                    }

                    // Average the color
                    IEnumerable <Entity> rgbEntities = onEntities.Where(x => x.Attributes.ContainsKey("rgb_color"));
                    if (rgbEntities.Any())
                    {
                        RGB averageColor = RGB.Average(rgbEntities.Select(x => new RGB(
                                                                              Convert.ToByte(x.Attributes["rgb_color"][0]),
                                                                              Convert.ToByte(x.Attributes["rgb_color"][1]),
                                                                              Convert.ToByte(x.Attributes["rgb_color"][2]))).Cast <RGB>());

                        SetColorWheelLocation(averageColor);

                        ShowColorWheelCircle(Visibility.Visible);
                    }
                    else
                    {
                        ShowColorWheelCircle(Visibility.Collapsed);
                    }
                }
                else
                {
                    UpdateBrightnessControl(0.0);

                    ShowColorTemperatureCircle(Visibility.Collapsed);
                    ShowColorWheelCircle(Visibility.Collapsed);
                }
            }
            else
            {
                if (string.Equals(PanelEntity.State, "on", StringComparison.InvariantCultureIgnoreCase))
                {
                    if (PanelEntity.Attributes.ContainsKey("brightness"))
                    {
                        UpdateBrightnessControl(Convert.ToDouble(PanelEntity.Attributes["brightness"]));
                    }
                    else
                    {
                        Ellipse ellipse = this.FindName("BrightnessCircle") as Ellipse;
                        ellipse.Visibility = Visibility.Collapsed;
                    }

                    if (PanelEntity.Attributes.ContainsKey("color_temp"))
                    {
                        UpdateColorTemperatureControl(Convert.ToInt32(PanelEntity.Attributes["color_temp"]));

                        ShowColorTemperatureCircle(Visibility.Visible);
                    }
                    else
                    {
                        ShowColorTemperatureCircle(Visibility.Collapsed);
                    }

                    if (PanelEntity.Attributes.ContainsKey("rgb_color"))
                    {
                        Newtonsoft.Json.Linq.JArray rgbColors = PanelEntity.Attributes["rgb_color"];

                        RGB rgb = new RGB()
                        {
                            R = Convert.ToByte(rgbColors[0]),
                            G = Convert.ToByte(rgbColors[1]),
                            B = Convert.ToByte(rgbColors[2]),
                        };

                        SetColorWheelLocation(rgb);

                        ShowColorWheelCircle(Visibility.Visible);
                    }
                    else
                    {
                        ShowColorWheelCircle(Visibility.Collapsed);
                    }
                }
                else
                {
                    UpdateBrightnessControl(0.0);

                    ShowColorTemperatureCircle(Visibility.Collapsed);
                    ShowColorWheelCircle(Visibility.Collapsed);
                }
            }

            // ColorTemperature should be a constant yellowish-hue line for brightness-only lights
            if (!PanelEntity.HasSupportedFeatures((uint)LightPlatformSupportedFeatures.ColorTemperature, ChildrenEntities))
            {
                Rectangle colorTemperature = this.FindName("ColorTemperature") as Rectangle;
                colorTemperature.Fill = new SolidColorBrush(Colors.LightYellow);
            }

            // Update the power button last so as to render with any color updates
            ShowHightlightColor(ButtonState.NotPressed);
        }