C# (CSharp) ArgusPaintNet.Shared.Matrix Exemples

Exemple #1

 public ConvolutionConfigEffectToken(ConvolutionConfigEffectToken copyToken)
     : base(copyToken)
 {
     this.Kernel    = new ArgusPaintNet.Shared.Matrix(copyToken.Kernel);
     this.Factor    = copyToken.Factor;
     this.Normalize = copyToken.Normalize;
 }

Exemple #2

 public ConvolutionConfigEffectToken()
     : base()
 {
     this.Kernel = new float[, ] {
         { 1 }
     };
     this.Factor    = 1;
     this.Normalize = true;
 }

Exemple #3

 public ConvolutionConfigEffectToken(ArgusPaintNet.Shared.Matrix kernel, float factor, bool normalize)
 {
     this.Kernel    = kernel;
     this.Factor    = factor;
     this.Normalize = normalize;
 }

Exemple #4

        private void Render(Rectangle rect, Surface srcSurface, Surface dstSurface)
#endif
        {
            ArgusPaintNet.Shared.Matrix kernel = this.Token.Kernel;
            float     factor    = this.Token.Factor * kernel.GetNormalizationFactor();
            int       kWidth    = kernel.ColumnCount;
            int       kHeight   = kernel.RowCount;
            Rectangle srcBounds = this.EnvironmentParameters.SourceSurface.Bounds;

            for (int y = rect.Top; y < rect.Bottom; y++)
            {
                if (this.IsCancelRequested)
                {
                    return;
                }

#if UNSAFE
                ColorBgra *[] pointers = new ColorBgra *[kHeight];
                for (int row = 0; row < kHeight; row++)
                {
                    int sy = y + row - kHeight / 2;
                    if (sy < 0 || sy >= srcBounds.Height)
                    {
                        pointers[row] = null;
                        continue;
                    }
                    pointers[row] = srcSurface.GetPointAddress(0, sy);
                }
#endif

#if UNSAFE
                for (int x = 0; x < rect.Width; x++)
#else
                for (int x = rect.Left; x < rect.Right; x++)
#endif
                {
                    float r = 0;
                    float g = 0;
                    float b = 0;

                    for (int col = 0; col < kWidth; col++)
                    {
                        int sx = x + col - kWidth / 2;
                        if (sx < 0 || sx >= srcBounds.Width)
                        {
                            continue;
                        }

                        for (int row = 0; row < kHeight; row++)
                        {
#if UNSAFE
                            if (pointers[row] == null)
                            {
                                continue;
                            }
                            ColorBgra px = pointers[row][sx];
#else
                            int sy = y + row - kHeight / 2;
                            if (sy < 0 || sy >= srcBounds.Height)
                            {
                                continue;
                            }

                            ColorBgra px = srcSurface[sx, sy];
#endif
                            r += kernel[row, col] * px.R * factor;
                            g += kernel[row, col] * px.G * factor;
                            b += kernel[row, col] * px.B * factor;
                        }
                    }

                    dstSurface[x, y] = ColorBgra.FromBgraClamped(Math.Abs(b), Math.Abs(g), Math.Abs(r), 255);
                }
            }
        }