Perlin Noise issue - c++

Question

I've created a Perlin noise function. My issue is when I generate a terrain map from the noise it ends up blocky, nothing like the cloudlike images I've seen. I'm curious on what I'm doing wrong (if anything).
here's my code:
main.cpp
#include "PerlinNoise.h"
#include <stdio.h>
#include <SDL/SDL.h>
void DrawPixel(SDL_Surface *screen, int x, int y, Uint8 R, Uint8 G, Uint8 B);
SDL_Surface *Render_Noise(int w, int h, int r, int g, int b);
PerlinNoise noiseGen(2,.5,25);
int main(int argc, char **argv)
{
SDL_Init(SDL_INIT_EVERYTHING);
SDL_Surface *screen = SDL_SetVideoMode(500,500,32,SDL_SWSURFACE);
SDL_Surface *noise = Render_Noise(500,500,255,255,255);
SDL_SaveBMP(noise, "noise.bmp");
bool quit = false;
while(!quit)
{
SDL_Event e;
SDL_WaitEvent(&e);
switch(e.type)
{
case SDL_QUIT:
quit = true;
}
SDL_BlitSurface(noise,NULL,screen,NULL);
SDL_Flip(screen);
SDL_Delay(2000);
}
SDL_FreeSurface(noise);
SDL_Quit();
return 0;
}
void DrawPixel(SDL_Surface *screen, int x, int y, Uint8 R, Uint8 G, Uint8 B)
{
Uint32 color = SDL_MapRGB(screen->format, R, G, B);
if(SDL_MUSTLOCK(screen))
{
if(SDL_LockSurface(screen) < 0)
{
return;
}
}
switch(screen->format->BytesPerPixel)
{
case 1:
{
Uint8 *bufp;
bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
*bufp = color;
}
break;
case 2:
{
Uint16 *bufp;
bufp = (Uint16 *)screen->pixels + y*screen->pitch/2 + x;
*bufp = color;
}
break;
case 3:
{
Uint8 *bufp;
bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
*(bufp+screen->format->Rshift/8) = R;
*(bufp+screen->format->Bshift/8) = B;
*(bufp+screen->format->Gshift/8) = G;
}
break;
case 4:
{
Uint32 *bufp;
bufp = (Uint32 *)screen->pixels + y*screen->pitch/4 + x;
*bufp = color;
}
break;
}
if(SDL_MUSTLOCK(screen))
{
SDL_UnlockSurface(screen);
}
SDL_UpdateRect(screen, x, y, 1, 1);
}
SDL_Surface *Render_Noise(int w, int h, int r, int g, int b)
{
SDL_Surface *ret = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,32,0,0,0,0); //create an empty image
for(int y = 0; y < h; y++)
{
for(int x = 0; x < w; x++)
{
double getnoise = 0;
for(int a = 0; a < noiseGen.n; a++)
{
getnoise += noiseGen.generateNoise(x,y);
noiseGen.z = rand() % 100;
}
getnoise / noiseGen.n;
int color = (int)((getnoise * 128.0) + 128.0); //convert noise to 0-256 value
if (color > 255)
color = 255;
if (color < 0)
color = 0;
DrawPixel( ret, x, y, (int)((r/255.0) * (double)color), (int)((g/255.0) * (double)color), (int)((b/255.0) * (double)color) );
}
}
return ret;
}
perlinnoise.cpp
#include "PerlinNoise.h"
PerlinNoise::PerlinNoise(int octaves, double persistence, int zoom)
{
p = persistence;
n = octaves - 1;
z = zoom;
}
PerlinNoise::~PerlinNoise()
{
}
///<summary>Gets a random number using x and y as seeds </summary>
///<param name = x> A double value </param>
///<param name = y> A double value </param>
///<returns> A random number between -1.0 and 1.0 </returns>
inline double PerlinNoise::noise(double x, double y)
{
int n = x + y * 57;
n = (n << 13) ^ n;
return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0);
}
///<summary> Smooths out noise values </summary>
///<param name = x> a double value </param>
///<param name = y> a double value </param>
///<returns> a smoothed value between -1.0 and 1.0 </returns>
double PerlinNoise::smoothNoise(double x, double y)
{
double corners = (noise(x+1, y+1) + noise(x+1,y-1) + noise(x-1,y+1) + noise(x-1,y-1)) / 16;
double sides = (noise(x,y+1) + noise(x,y-1) + noise(x+1,y) + noise(x-1,y)) / 8;
double center = noise(x,y) / 4;
return corners + sides + center;
}
///<summary> Cosine Interpolation </summary>
///<param name = a> The low value to be interpolated </param>
///<param name = b> The high value to be interpolated </param>
///<param name = x> A value between -1.0 and 1.0 </param>
///<returns> Interpolated value between a and b </returns>
double PerlinNoise::cosineInterpolation(double a, double b, double x)
{
double ft = x * 3.1415927;
double f = (1.0 - cos(ft)) * .5;
return a * (1.0 - f) + b * f;
}
///<summary> Gets smoothed noise values and interpolates them </summary>
///<param name = x> a double value </param>
///<param name = y> a double value </param>
///<returns> a value between -1 and 1 that's been smoothed and interpolated </returns>
double PerlinNoise::interpolatedNoise(double x, double y)
{
double integer_x = (int)x;
double fractional_x = x - integer_x;
double integer_y = (int)y;
double fractional_y = y - integer_y;
double v1 = smoothNoise(integer_x, integer_y);
double v2 = smoothNoise(integer_x + 1, integer_y);
double v3 = smoothNoise(integer_x, integer_y + 1);
double v4 = smoothNoise(integer_x + 1, integer_y + 1);
double inter1 = cosineInterpolation(v1, v2, fractional_x);
double inter2 = cosineInterpolation(v3, v4, fractional_x);
return cosineInterpolation(inter1, inter2, fractional_y);
}
double PerlinNoise::generateNoise(double x, double y)
{
double total = 0;
for(int i = 0; i < n; i++)
{
frequency = pow(2.0,i);
amplitude = pow(p,i);
total = total + interpolatedNoise(x * frequency / z, y * frequency / z) * amplitude;
}
return total;
}

Answer 1

Found the problem, my persistence was much lower than it should be, upping that I got the cloudlike image I expected