Welcome to Fractal Forums

SideLength = (2^x) + 1
while SideLength >= 2
{
    HalfSide = SideLength / 2;

    //diamond step
    for (int x = 0; x < Size - 1; x = x + SideLength)
        {
             for (int y = 0; y < Size - 1; y = y + SideLength)
             {
                   Heights[x + HalfSide, y + HalfSide] = (Heights[x, y] + Heights[x + SideLength, y] + 
                       Heights[x, y + SideLength] + Heights[x + SideLength, y + SideLength]) / 4 +- Randomness;
              }
        }
    
    //square step
    for (int x = 0; x < Size - 1; x = x + SideLength)
    {
         for (int y = 0; y < Size - 1; y = y + SideLength)
         {
              if (y != 0)
              Heights[x + HalfSide, y] = (Heights[x, y] + Heights[x + SideLength, y] + 
                  Heights[x + HalfSide, y + HalfSide] + Heights[x + HalfSide, y - HalfSide]) / 4 +- Randomness;

              if (x != 0)
              Heights[x, y + HalfSide].y = (Heights[x, y].y + Heights[x, y + SideLength].y + 
                  Heights[x + HalfSide, y + HalfSide].y + Heights[x - HalfSide, y + HalfSide].y) / 4 +- Randomness;
         }
    }
    SideLength = SideLength / 2;
    Randomness = Randomness / Roughness; 
    }
}

private void CreateHeights()
        {
            if (cbUseLand.Checked == false) 
                return;
            int
                Size = Convert.ToInt32(System.Math.Pow(2, int.Parse(tbDetail.Text)) + 1),
                SideLength = Size - 1,
                d = 1025 / (Size - 1),
                HalfSide;
            Heights = new Point3D[Size, Size];
            float
                r = float.Parse(tbHeight.Text),
                Roughness = float.Parse(RoughnessBox.Text);

            for (int x = 0; x < Size; x++)
                for (int y = 0; y < Size; y++)
                    Heights[x, y] = Make3DPoint(x * d, 740, y * d);

            while (SideLength >= 2)
            {
                HalfSide = SideLength / 2;

                for (int x = 0; x < Size - 1; x = x + SideLength)
                {
                    for (int y = 0; y < Size - 1; y = y + SideLength)
                    {
                        Heights[x + HalfSide, y + HalfSide].y =
                          (Heights[x, y].y +
                          Heights[x + SideLength, y].y +
                          Heights[x, y + SideLength].y +
                          Heights[x + SideLength, y + SideLength].y) / 4 - r + ((float)(random.NextDouble() * r) * 2);
                    }
                }

                for (int x = 0; x < Size - 1; x = x + SideLength)
                {
                    for (int y = 0; y < Size - 1; y = y + SideLength)
                    {
                        if (y != 0)
                            Heights[x + HalfSide, y].y = (Heights[x, y].y + Heights[x + SideLength, y].y + Heights[x + HalfSide, y + HalfSide].y + Heights[x + HalfSide, y - HalfSide].y) / 4 - r + ((float)(random.NextDouble() * r) * 2); 
                        if (x != 0)
                            Heights[x, y + HalfSide].y = (Heights[x, y].y + Heights[x, y + SideLength].y + Heights[x + HalfSide, y + HalfSide].y + Heights[x - HalfSide, y + HalfSide].y) / 4 - r + ((float)(random.NextDouble() * r) * 2);
                    }
                }
                SideLength = SideLength / 2;
                r = r / Roughness;
            }
        }

    r = AnyNumberAtAll;
    for (int a = 0; a < 20000; a++)
            {
                f += -r + (float)(random.NextDouble() * (r * 2));
            }
            Write((f / 20000).ToString());

filter(s){//s is the "strength" of the filter. A good value is around 10 if the heigtmap max height is around 1
   //edges are not processed here but they need to!
   for(l=1; l<N; l++)
      for(c=1; c<N; c++){
         G=tab[l][c]-tab[l-1][c]; G+=tab[l][c]-tab[l+1][c];
         G+=tab[l][c]-tab[l][c-1]; G+=tab[l][c]-tab[l][c+1];//"gradients" in the 4 directions. abs(G) will be higher on spike and "pits". 
         G=exp(-s*abs(G));//in order to have in in the range [-1, 1]
         tab[l][c]=G*tab[l][c]+0.25*(1-G)*(tab[l-1][c]+tab[l+1][c]+tab[l][c-1]+tab[l][c+1]);//simple filter
      }
}

void model()  
{
  
  
  
  int
    Size = GRID,
    SideLength = Size - 1,
    SideLength2 = Size - 1,
    d = 1025 / (Size - 1),
    HalfSide, 
    HalfSide2,
    QSide2;
  //Heights = new Point3D[Size, Size];
  //float
  float r = r_init;
  float e = Erosion;
  //Roughness = float.Parse(RoughnessBox.Text);
  float hit;
  int grid_cnt = 0;

  srand(rand_init);

  for (int x = 0; x < Size; x++)
    for (int y = 0; y < Size; y++)
      Heights[x][y] = 0;

  
  while (SideLength2 >= 4)
    {
      HalfSide = SideLength / 2;
      HalfSide2 = SideLength2 / 2;
      QSide2 = HalfSide2 / 2;
      if(SideLength >=2){
	if(SideLength == 2) r = r / Roughness;
	for (int x = 0; x < Size - 1; x = x + SideLength)
	  {
	    for (int y = 0; y < Size - 1; y = y + SideLength)
	      {
		Heights[x + HalfSide][ y + HalfSide] =
		  (Heights[x][ y] +
		   Heights[x + SideLength][ y] +
		   Heights[x][ y + SideLength] +
		   Heights[x + SideLength][ y + SideLength]) / 4 + r - 2*r*(rand()/(1.0*RAND_MAX));
	      }
	  }
	
	for (int x = 0; x < Size - 1; x = x + SideLength)
	  {
	    for (int y = 0; y < Size - 1; y = y + SideLength)
	      {
		if (y != 0)
		  Heights[x + HalfSide][ y] = 
		    (Heights[x][ y] + Heights[x + SideLength][ y] + Heights[x + HalfSide][ y + HalfSide] + Heights[x + HalfSide][ y - HalfSide]) / 4 + r - 2*r*(rand()/(1.0*RAND_MAX)); 
		if (x != 0)
		  Heights[x][ y + HalfSide] = 
		    (Heights[x][ y] + Heights[x][ y + SideLength] + Heights[x + HalfSide][ y + HalfSide] + Heights[x - HalfSide][ y + HalfSide]) / 4 + r - 2*r*(rand()/(1.0*RAND_MAX));
	      }
	  }
      }
      
      if(grid_cnt >= Erosion_delay){
	for (int x = 0; x < Size - 1; x = x + SideLength2)
	  {
	    for (int y = 0; y < Size - 1; y = y + SideLength2)
	      {
		
		Heights[x + HalfSide2][ y + HalfSide2] = Heights[x + HalfSide2][ y + HalfSide2]*(1-e)+
		  (Heights[x + QSide2][ y + QSide2] +
		   Heights[x + SideLength2 - QSide2][ y + QSide2] +
		   Heights[x + QSide2][ y + SideLength2 - QSide2] +
		   Heights[x + SideLength2 - QSide2][ y + SideLength2 - QSide2]) * e / 4;
		
	      }
	  }
	
	for (int x = 0; x < Size - 1; x = x + SideLength2)
	  {
	    for (int y = 0; y < Size - 1; y = y + SideLength2)
	      {
		if (y != 0)
		  Heights[x + HalfSide2][ y] = Heights[x + HalfSide2][ y]*(1-e)+
		    (Heights[x + QSide2][ y] + Heights[x + SideLength2 - QSide2][ y] + 
		     Heights[x + HalfSide2][ y  + QSide2] + Heights[x + HalfSide2][ y - QSide2]) * e / 4; 
		if (x != 0)
		Heights[x][ y + HalfSide2] = Heights[x][ y + HalfSide2]*(1-e)+
		  (Heights[x][ y + QSide2] + Heights[x][ y + SideLength2 - QSide2] + 
		   Heights[x + QSide2][ y + HalfSide2] + Heights[x - QSide2][ y + HalfSide2]) * e / 4 ;
	      }
	  }
	SideLength2 = SideLength2 / 2;	
      }
      
      grid_cnt++;
      SideLength = SideLength / 2;
      r = r / Roughness;
    }
}

F[x][y] <- 1/4*(F[x+1][y]+F[x-1][y]+F[x][y+1]+F[x][y-1]+g[x][y])

testSquare {
; 0                   1                   2                   3
; b       *1          b        *1         b        *1         b
;
;
;          0          1         2         3         4
;*2       *3         *2        *3        *2        *3        *2
;
; 4                   5                   6                   7
;          5          6         7         8         9
; b       *1          b        *1         b        *1         b
;
;
;         10         11        12        13        14
;*2       *3         *2        *3        *2        *3        *2
;
; 8                   9                  10                  11
;         15         16        17        18        19
; b       *1          b        *1         b        *1         b
;
;
;         20         21        22        23        24
;*2       *3         *2        *3        *2        *3        *2
;
;12                  13                  14                  15
;
; b        *1         b        *1         b        *1         b
global:
  int r[3*62]
  int i = 0
  int seed = @seed
  repeat
    r[i] = seed = random(seed)
  until (i=i+1)>=3*(@depth+@rand)
init:
  float h[16]
  float nh[25]
  float x = (0.25*real(#pixel))%1.0
  float y = (0.25*imag(#pixel))%1.0
  float f = 1.0/#randomrange
  float q = 2.0^(@depth+@rand-1)
  int v[16]
  int nv[25]
  int d = 0
  int j = 0
  int k = 0
  int m = 0
  if x<0.0
    x = x + 1.0
  endif
  if y<0.0
    y = y + 1.0
  endif
  x = x*2.0^(@depth+@rand)
  y = y*2.0^(@depth+@rand)
  repeat
    h[d] = 0.0
    v[d] = 0
  until (d=d+1)>=16
  d = 0
loop:
  repeat
    m = 0
    if y>=q
      y = y - q
      m = m + 5
    endif
    if x>=q
      x = x - q
      m = m + 1
    endif
    if d<@rand*3
      j = 0
      k = 0
      repeat
        nh[k] = f*(nv[k]=v[j]+r[d+2])
        nh[k+2] = f*(nv[k+2]=v[j+1]+r[d+2])
        nh[k+4] = f*(nv[k+4]=v[j+2]+r[d+2])
        j = j + 4
      until (k=k+10)>=25
      j = 0
      k = 0
      repeat
        nh[k+1] = f*(nv[k+1]=v[j+1]+r[d+1])
        nh[k+3] = f*(nv[k+3]=v[j+2]+r[d+1])
        nh[k+5] = f*(nv[k+5]=v[j+4]+r[d])
        nh[k+6] = h[j+5]
        nv[k+6] = v[j+5]
        nh[k+7] = f*(nv[k+7]=v[j+5]+r[d])
        nh[k+8] = h[j+6]
        nv[k+8] = v[j+6]
        nh[k+9] = f*(nv[k+9]=v[j+6]+r[d])
        j = j + 4
      until (k=k+10)>=20
      nh[k+1] = f*(nv[k+1]=v[j+1]+r[d+1])
      nh[k+3] = f*(nv[k+3]=v[j+2]+r[d+1])
    else
      j = 0
      k = 0
      repeat
        nh[k] = 0.25*(h[j]+h[j+1]+h[j+4]+h[j+5]) + f*(nv[k]=v[j]+r[d+2])
        nh[k+2] = 0.25*(h[j+1]+h[j+2]+h[j+5]+h[j+6]) + f*(nv[k+2]=v[j+1]+r[d+2])
        nh[k+4] = 0.25*(h[j+2]+h[j+3]+h[j+6]+h[j+7]) + f*(nv[k+4]=v[j+2]+r[d+2])
        j = j + 4
      until (k=k+10)>=25
      j = 0
      k = 0
      repeat
        nh[k+1] = 0.25*(h[j+1]+nh[k]+nh[k+2]+h[j+5]) + f*(nv[k+1]=v[j+1]+r[d+1])
        nh[k+3] = 0.25*(h[j+2]+nh[k+2]+nh[k+4]+h[j+6]) + f*(nv[k+3]=v[j+2]+r[d+1])
        nh[k+5] = 0.25*(nh[k]+h[j+4]+h[j+5]+nh[k+10]) + f*(nv[k+5]=v[j+4]+r[d])
        nh[k+6] = h[j+5]
        nv[k+6] = v[j+5]
        nh[k+7] = 0.25*(nh[k+2]+h[j+5]+h[j+6]+nh[k+12]) + f*(nv[k+7]=v[j+5]+r[d])
        nh[k+8] = h[j+6]
        nv[k+8] = v[j+6]
        nh[k+9] = 0.25*(nh[k+4]+h[j+6]+h[j+7]+nh[k+14]) + f*(nv[k+9]=v[j+6]+r[d])
        j = j + 4
      until (k=k+10)>=20
      nh[k+1] = 0.25*(h[j+1]+nh[k]+nh[k+2]+h[j+5]) + f*(nv[k+1]=v[j+1]+r[d+1])
      nh[k+3] = 0.25*(h[j+2]+nh[k+2]+nh[k+4]+h[j+6]) + f*(nv[k+3]=v[j+2]+r[d+1])
      f = @sharp*f
    endif
    j = 0
    repeat
      k = 0
      repeat
        h[j] = nh[m]
        v[j] = nv[m]
        j = j + 1
        m = m + 1
      until (k=k+1)>=4
      m = m + 1
    until j>=16
    q = 0.5*q
  until (!@fast && q<1) || (@fast && x==0.0 && y==0.0) \
        || (d=d+3)>=3*(@depth+@rand)
  if @fast
    z = ((0.5/@scale)+h[5])*@scale
  else
    z = ((0.5/@scale)+0.25*(h[5]+h[6]+h[9]+h[10]))*@scale
  endif
bailout:
 false
default:
  title = "Diamond Square wrapped"
  magn = 0.75
  int param depth
    caption = "fBm Depth"
    default = 10
    min = 2
    max = 31
    hint = "Defines rhe detail level i.e. the resolution of the fBm. \
            A value of 2 gives fBm 4*4 detail, a value of \
            3 gives fBm with 8*8 detail and so on. So the default \
            of 9 gives fBm with 512*512 detail and a value of \
            31 gives you fBm with detail 2147483648*2147483648. \
            The overall detail of the random patterns is also controlled \
            by the Random Depth value and that adds or removes detail in \
            powers of 2 in a similar manner. For instance the defaults of 9 \
            for the fBm Depth and 1 for the Random Depth combine to give an \
            overall detail level of 1024*1024 for the complete wrapped \
            pattern. Essentially this means at UF Magnification 1 for a layer \
            then a combined value of 14 is enough even for print size renders \
            at say 8000*8000 pixels and if you are at higher magnification \
            you simply add one to the combined depth per doubling of thr UF \
            magnification or per doubling of the render resolution and you \
            can similarly reduce the value by one for each halving of the \
            magnification or render resolution. So in fact for a normal work \
            render in a 640*480 window with UF magnificastion 1 then a \
            combined Depth of 10 (==1024*1024) is good enough for accurate \
            representation of results when the value is increased to account \
            for higher render resolution/increased magnificatiion. Of course \
            the lower the Depth, the faster the render. Changing the Bit \
            Depth only alters the resolution of the pattern, not the shape, \
            so if wanting exactly similar results at different detail levels \
            then changing the fBm Depth is better than chnging the Random \
            Depth though that couuld also be done when there's no choice \
            left i.e. for reducing detail when fBm Depth is 2 or increasing \
            detail when fBm Depth is 31."
  endparam
  int param rand
    caption = "Random Depth"
    default = 0
    min = 0
    max = 31
    hint = "Specifying values >0 causes the random algorithm to add the \
            specified number of bit-depths prior to the diamond-square method \
            as being raw randoms. This can be used to add more variation to \
            the wrapped fBm squares, the more random depths specified then \
            the more variety you get. Of course when using values >0 then \
            the overall detail level of the wrapped squares is increased and \
            for optimum rendering you need to consider the sum of Bit Depth \
            and Random Depth with respect to magnification and pixel \
            resolution changes. Each Random Depth has less overhead \
            than each Bit Depth in terms of render time. Note that although \
            changing the Bit Depth alone does not really change the patterns \
            (other than their resolution) changing the Random Depth will \
            result in noticeable changes to the pattern by increasing the \
            variation as the Random Depth is increased and vice-versa."
  endparam
  float param sharp
    caption = "Sharpness"
    default = 0.707106781186548
    min = 0
    hint = "The larger the value then the 'sharper' the fBm, in general \
            values from 0.4 to 0.8 work best."
  endparam
  int param seed
    caption = "Random Seed"
    default = 12
    hint = "Use any value you like, each will produce a different pattern. \
            Because of the nature of the UF random generator some values \
            will produce patterns with obvious non-random patterns in them. \
            Just try values until you find one that's of a style you require \
            i.e. one that's more like pure fBm or one that has some \
            non-randomness in it."
  endparam
  float param scale
    caption = "Scale"
    default = 4.0
    hint = "Can be used to adjust the gradient indexes so they are restricted \
            to the range 0 to 1 i.e. so they don't wrap round the gradient. \
            Decrease the value if unwanted gradient wrapping is occurring. \
            The higher you set the 'Sharpness' then the more likely gradient \
            wrapping is to occur."
  endparam
  bool param fast
    caption = "Fast with artifice"
    default = true
    hint = "When enabled the renders will be marginally faster and there will \
            be slightly more noticeable artifice in the patterns at the \
            lowest detail level of the selected overall depth."
  endparam
}

return 2*(rnd<0.1 ? 0.9 :-0.1);

weight=linearInterpolation(1,rnd,intrpolparam0)*2^(strengthParam*levelOfCurrentPoint*linearInterpolation(1,rnd,intrpolparam1))