Exemple #1
0
        public override void WriteToBitmap(Canvas canvas)
        {
            PrepareWriteBitmap(canvas);

            /*			int[,] array1 = new int[a_bmp.Width,a_bmp.Height];
            int[,] array2 = new int[a_bmp.Width,a_bmp.Height];
            int[,] arrayTmp;

            for(int x=0; x<a_bmp.Width; x++)
            {
                for(int y=0; y<a_bmp.Height; y++)
                    array2[x,y] = (int)(255*(0.5*GetRandomValue(x, y)+0.5));
            }

            int m_nNumIterations = 1;
            for (int i=0; i<m_nNumIterations; i++)
            {
                for(int x=1; x<a_bmp.Width-1; x++)
                {
                    for(int y=1; y<a_bmp.Height-1; y++)
                    {
                        array1[x,y] =
                                       ((array2[x-1, y-1]+array2[x+1, y-1]+
                                       array2[x-1, y+1]+array2[x+1, y+1]+
                                       array2[x-1, y] +array2[x+1, y]+
                                       array2[x, y-1] +array2[x, y+1]+
                                       array2[x, y]) / 9)+1;
                    }
                    arrayTmp = (int[,])array2.Clone();
                    array2 = (int[,])array1.Clone();
                    array1 = (int[,])arrayTmp.Clone();
                }
            }

            for(int x=0; x<a_bmp.Width; x++)
            {
                for(int y=0; y<a_bmp.Height; y++)
                    a_bmp.SetPixel(x,y, Color.FromArgb(array2[x,y],0,0));
            }
            return;
            */

            for (int x = canvas.Width - 1; x >= 0; x--)
            {
                for (int y = canvas.Height - 1; y >= 0; y--)
                {
                    float xValue = (x - canvas.Width / 2) / (float)canvas.Width;
                    float yValue = (y - canvas.Height / 2) / (float)canvas.Height;
                    double distValue = Math.Sqrt(xValue * xValue + yValue * yValue);
                    double d = distValue + m_fTurbulence * GetNoiseValue(x, y, m_nOctaves);
                    float total = (float)Math.Sin(2 * m_fNumCircles * d * 3.14159);

                    total = total*0.5f + 0.5f;
                    int fin = (int)(total*255);

                    Color clr = (Color)m_aColorTable[fin];
                    canvas.SetPixel(x, y, clr);
                }
            }
        }
Exemple #2
0
        public override void WriteToBitmap(Canvas canvas)
        {
            Random rnd = new Random();
            this.PrepareWriteBitmap(canvas);
            int[,] array1 = new int[canvas.Width, canvas.Height];
            int[,] array2 = new int[canvas.Width, canvas.Height];
            for (int x = 0; x < canvas.Width; x++)
            {
                for (int y = 0; y < canvas.Height; y++)
                {
                    array1[x,y] = rnd.Next(255);
                }
            }

            double m_dRate = 0.1;

            for (int nStep = 0; nStep < 50; nStep++)
            {
                //' Run the cellular automata step:
                for (int x = 0; x < canvas.Width; x++)
                {
                    for (int y = 0; y < canvas.Height; y++)
                    {
                        double dTot = 0;
                        for(int iX=-1; iX<=1; iX++)
                        {
                            int i = x + iX;
                            int j = 0;
                            if (i < 0) i = canvas.Width - 1;
                            else if (i >= canvas.Width) i = 0;
                            for(int iY=0; iY<=1; iY++)
                            {
                                j = y + iY;
                                if (j < 0) j = canvas.Height - 1;
                                else if (j >= canvas.Height) j = 0;
                                dTot+= array1[i,j];
                            }
                            dTot/= 9;
                            dTot+= m_dRate;
                            dTot = dTot - (int)dTot;
                            array2[i, j] = (int)(dTot * 255.0);
                        }
                    }
                }
                int[,] arrayTmp;
                arrayTmp = array2;
                array2= array1;
                array1 = arrayTmp;
            }

            for (int x = canvas.Width - 1; x >= 0; x--)
            {
                for (int y = canvas.Height - 1; y >= 0; y--)
                {
                    Color clr = (Color)m_aColorTable[array2[x,y]];
                    canvas.SetPixel(x, y, clr);
                }
            }
        }
Exemple #3
0
        public static Canvas Convolve(Canvas canvas, float[,] kernel)
        {
            //Bitmap bmp = ((Canvas)canvas).ToBitmap();
            Canvas canvasDst = canvas.CreateSimilar();
            //Bitmap bmpDst = new Bitmap(canvas.Width, canvas.Height, bmp.PixelFormat);
            //Canvas canvasDst = Canvas.Create(bmpDst);
            canvasDst.Locked = true;
            canvas.Locked = true;

            EPoint pntKernelSize = new EPoint(kernel.GetLength(0), kernel.GetLength(1));

            int nBpp = canvas.BitsPerPixel / 8;
            //TODO: what to do with palettes in D3D..?
            //if (nBpp == 1)
            //    bmpDst.Palette = bmp.Palette;

            EPoint canvasSize = new EPoint(canvas.Width, canvas.Height);
            float[] vals = new float[nBpp];
            for (int y = pntKernelSize.Y / 2; y < canvasSize.Y - pntKernelSize.Y / 2; y++)
            {
                for (int x = pntKernelSize.X / 2; x < canvasSize.X - pntKernelSize.X / 2; x++)
                {
                    for (int channel = 0; channel < nBpp; channel++)
                        vals[channel] = 0;

                    for (int yKernel = 0; yKernel < pntKernelSize.Y; yKernel++)
                    {
                        for (int xKernel = 0; xKernel < pntKernelSize.X; xKernel++)
                        {
                            int clr = canvas.GetPixelInt(
                                x + xKernel - pntKernelSize.X / 2,
                                y + yKernel - pntKernelSize.Y / 2);

                            for (int channel = 0; channel < nBpp; channel++)
                            {
                                vals[channel] += kernel[xKernel, yKernel] * (float)(clr & 0xff);
                                clr >>= 8;
                            }
                        }
                    }

                    if (nBpp == 1)
                        canvasDst.SetPixelInt(x, y, vals[0] > 255 ? 255 : (int)vals[0]);
                    else if (nBpp == 3)
                        canvasDst.SetPixel(x, y, Color.FromArgb(
                            vals[2] > 255 ? 255 : (int)vals[2],
                            vals[1] > 255 ? 255 : (int)vals[1],
                            vals[0] > 255 ? 255 : (int)vals[0]));
                }
            }

            canvas.Locked = false;
            canvasDst.Locked = false;

            return canvasDst;
        }
Exemple #4
0
        public override void WriteToBitmap(Canvas canvas)
        {
            this.PrepareWriteBitmap(canvas);

            Random rnd = new Random();

            double dMasterWL = 0.001/m_fFreq;
            double dXWLFact = rnd.NextDouble()*2+2;
            double dXYWLFact = rnd.NextDouble()*2+2;
            double dYWLFact = rnd.NextDouble()*2+2;
            double[] aOffsetsPerOctave = new double[3*m_nOctaves];
            for (int nOctave = 0; nOctave < m_nOctaves; nOctave++)
            {
                for (int i = 0; i < 3; i++)
                    aOffsetsPerOctave[nOctave*3+i] = rnd.NextDouble()*3.1;
            }

            double dMax = -1000;
            double dMin = 1000;
            double[,] array = new double[canvas.Width, canvas.Height];

            for (int x = 0; x < canvas.Width; x++)
            {
                for (int y = 0; y < canvas.Height; y++)
                {
                    double dAmplitude = 1.0;
                    double dTotal = 0;
                    for (int nOctave = 1; nOctave <= m_nOctaves; nOctave++)
                    {
                        double z1 = Math.Sin(dXWLFact*x*nOctave*dMasterWL +aOffsetsPerOctave[(nOctave-1)*3+0]);
                        double z2 = Math.Sin((dXYWLFact*x*nOctave+y*nOctave)*dMasterWL +aOffsetsPerOctave[(nOctave-1)*3+1]);
                        double z3 = Math.Sin(dYWLFact*y*nOctave*dMasterWL+aOffsetsPerOctave[(nOctave-1)*3+2]);
                        dTotal+=dAmplitude*Math.Abs(z1+z2+z3);
                        dAmplitude*=m_fDecay;
                    }
                    array[x,y] = dTotal;
                    dMax = Math.Max(dMax, dTotal);
                    dMin = Math.Min(dMin, dTotal);
                }
            }

            for (int x = canvas.Width - 1; x >= 0; x--)
            {
                for (int y = canvas.Height - 1; y >= 0; y--)
                {
                    Color clr = (Color)m_aColorTable[(int)((array[x,y]-dMin)/(dMax+dMin)*255)];
                    canvas.SetPixel(x, y, clr);
                }
            }
        }
Exemple #5
0
        public override void WriteToBitmap(Canvas canvas)
        {
            this.PrepareWriteBitmap(canvas);

            for (int x = canvas.Width - 1; x >= 0; x--)
            {
                for (int y = canvas.Height - 1; y >= 0; y--)
                {
                    float xyValue = 1f*(float)x * m_pntPeriods.X / m_nNoiseWidth + (float)y * m_pntPeriods.Y / m_nNoiseHeight;
                    //xyValue += (float)x * xPeriod / a_bmp.Width + (float)y * yPeriod / a_bmp.Height;
                    xyValue += m_fTurbulence*GetNoiseValue(x, y, m_nOctaves);
                    float total = (float)(Math.Sin(xyValue * 3.14159)); //Math.Abs

                    total = total*0.5f + 0.5f;
                    int fin = (int)(total*255);

                    Color clr = (Color)m_aColorTable[fin];
                    canvas.SetPixel(x, y, clr);
                }
            }
        }
Exemple #6
0
 protected void PrepareWriteBitmap(Canvas canvas)
 {
     m_fScaleX = (float)m_nNoiseWidth / canvas.Width;
     m_fScaleY = (float)m_nNoiseHeight / canvas.Height;
 }
Exemple #7
0
        public virtual void WriteToBitmap(Canvas canvas)
        {
            this.PrepareWriteBitmap(canvas);

            for (int x = canvas.Width - 1; x >= 0; x--)
            {
                for (int y = canvas.Height - 1; y >= 0; y--)
                {
                    float total = GetNoiseValue((x+m_pntOffset.X)*m_fFreq, (y+m_pntOffset.Y)*m_fFreq, m_nOctaves);

                    total = total*0.5f + 0.5f;
                    int fin = (int)(total*255);

                    Color clr = (Color)m_aColorTable[fin];
                    canvas.SetPixel(x, y, clr);
                }
            }
        }