Create a new version of paste:

import random
import numpy as np
import math
try:
	from PIL import Image      # necessary for manipulation with images
	from PIL import ImageFilter
	from PIL import ImageDraw,ImageFont
except:
	print (" Warning: Failed to load Pillow (Imaging) modules!")
	print (" Pillow (fork of PIL) should be available in repositories")
	print (" of your distribution, please install it first.")
	exit()


length=2**10  #working size
rough_intensity=1.5  #1.5 good
rough_gamma=1.3      #0.85good
highcropprc=2
lowcropprc=5 #% water surface effectively
map_size=384  # final size in widelands
minavg=0.2
maxavg=0.45
seed_intensity=0.15 # 0.66 good, inserting additional randomnes before running diamond square algorithm


px_array=np.zeros(shape=(length,length),dtype=float)
blur_array=np.zeros(shape=(length,length),dtype=float)

def new_RGB(bp1,bp2,value,R1,G1,B1,R2,G2,B2):
	ratio=(float(value)-bp1)/(bp2-bp1)
	Rnew=R1*(1-ratio)+ R2*ratio
	Gnew=G1*(1-ratio)+ G2*ratio
	Bnew=B1*(1-ratio)+ B2*ratio
	return Rnew,Gnew,Bnew

def wrap(value):
	if value>=length:
		return value-length
	if value<0:
		return value+length
	return value
	

k=0
listofdef=[0,0.1,0.2,0.8,0.9,1]
while k<10:  #generates 10 fractals (=10 jpg images and txt files with heights)
	print ("Fractal: "+str(k+1))
	
	lowcount=0
	highcount=1
	px_array.fill(-100)    #defaults
	px_array[0 , 0]=random.uniform(0,1)   #at least one value must be given to start fractal generation
	
	#this is an exemption to fractal algorithm but we need to add more randomness/irregularity
	for i in range(8):
		for j in range(8):
			if random.uniform(0,1) > (1- seed_intensity):
				i_l=int(i/8.0*length)
				j_l=int(j/8.0*length)
				px_array[i_l, j_l]=random.choice(listofdef)

	sqsize=length
	
	while sqsize >1:
		roughness=math.pow(rough_intensity*float(sqsize)/length,rough_gamma)
		print ("  sqsize: "+str(sqsize)+", roughness: " +str(round(roughness,3)))
		#iterating over line, starting on 0+sqsize/2

		pixel_x_pos=0+sqsize/2
		
		while pixel_x_pos<length:
			pixel_y_pos=0+sqsize/2	
			while pixel_y_pos<length:	
				px1=	px_array[wrap(pixel_x_pos-sqsize/2) , wrap(pixel_y_pos-sqsize/2)]
				px2=	px_array[wrap(pixel_x_pos-sqsize/2) , wrap(pixel_y_pos+sqsize/2)]
				px3=	px_array[wrap(pixel_x_pos+sqsize/2) , wrap(pixel_y_pos-sqsize/2)]
				px4=	px_array[wrap(pixel_x_pos+sqsize/2) , wrap(pixel_y_pos+sqsize/2)]
					
				new_value=(px1+px2+px3+px4)/4.0 + random.uniform(-1,1)*roughness
				if new_value>1:
					highcount+=1
				if new_value<0:
					lowcount+=1			
				if px1==-100 or px2==-100 or px3==-100 or px4==-100:
					print ("   touched wrong pixel: "+str(pixel_x_pos)+" x "+str(pixel_y_pos))
					#exit()
				
				px_array[pixel_x_pos , pixel_y_pos]=new_value
				pixel_y_pos=pixel_y_pos+sqsize
			pixel_x_pos=pixel_x_pos+sqsize
		
		
		#iterating once more and populating not calculated pixels
		pixel_x_pos=0
		
		while pixel_x_pos<length:
			pixel_y_pos=0	
			while pixel_y_pos<length:
				#print (pixel_x_pos,pixel_y_pos)
				if px_array[pixel_x_pos,pixel_y_pos]>-100:   #never change yet calculated pixel
					pixel_y_pos=pixel_y_pos+sqsize/2
					continue

				px1=	px_array[wrap(pixel_x_pos-sqsize/2) , pixel_y_pos]
				px2=	px_array[wrap(pixel_x_pos+sqsize/2) , pixel_y_pos]
				px3=	px_array[pixel_x_pos , wrap(pixel_y_pos-sqsize/2)]
				px4=	px_array[pixel_x_pos , wrap(pixel_y_pos+sqsize/2)]	
				if px1==-100 or px2==-100 or px3==-100 or px4==-100:
					print ("   touched wrong pixel: "+str(pixel_x_pos)+" x "+str(pixel_y_pos))
					#exit()
					
				new_value=(px1+px2+px3+px4)/4.0 + random.uniform(-1,1)*roughness
				if new_value>1:
					highcount+=1
				if new_value<0:
					lowcount+=1
				#print (str(new_value)+" ( pure avg="+str((px1+px2+px3+px4)/4.0)+")    on pos :"+str(pixel_x_pos)+"  x  "+str(pixel_y_pos))
	
				px_array[pixel_x_pos , pixel_y_pos]=new_value
				
				pixel_y_pos=pixel_y_pos+sqsize/2
			pixel_x_pos=pixel_x_pos+sqsize/2
		
		sqsize=sqsize/2
	
	
	newImage = Image.new( 'RGB', (length,length), "black")
	
	#blurring the image
	for i in range(length):
		for j in range(length):
			if px_array[i][j]==-100:
				print ("unpopulated pixel")
				exit()
			blur_array[i,j]=(px_array[i,j] + px_array[i,j] + px_array[wrap(i+1),wrap(j)] +
			px_array[wrap(i-1),wrap(j)] + px_array[wrap(i),wrap(j+1)] + px_array[wrap(i),wrap(j-1)])/ 6.0
	#iteration 2
	for i in range(length):
		for j in range(length):
			px_array[i,j]=(blur_array[i,j]  + px_array[i,j] + blur_array[wrap(i+1),wrap(j)] +
			blur_array[wrap(i-1),wrap(j)] +  blur_array[wrap(i),wrap(j+1)] + blur_array[wrap(i),wrap(j-1)])/ 6.0
	#iteration 3
	for i in range(length):
		for j in range(length):
			blur_array[i,j]=(px_array[i,j] + px_array[i,j] + px_array[wrap(i+1),wrap(j)] +
			px_array[wrap(i-1),wrap(j)] + px_array[wrap(i),wrap(j+1)] + px_array[wrap(i),wrap(j-1)])/ 6.0
	#iteration 4
	for i in range(length):
		for j in range(length):
			px_array[i,j]=(blur_array[i,j]  + px_array[i,j] + blur_array[wrap(i+1),wrap(j)] +
			blur_array[wrap(i-1),wrap(j)] +  blur_array[wrap(i),wrap(j+1)] + blur_array[wrap(i),wrap(j-1)])/ 6.0	
	
	#normalizing the image, calculating minvalue and maxvalue
	minvalue=10
	maxvalue=-10

	for i in range(length):
		#print(str(i)+" : "+str(px_array[i]))
		for j in range(length):

			if  px_array[i][j]<minvalue:
					minvalue=px_array[i][j]
			elif  px_array[i][j]>maxvalue:
					maxvalue=px_array[i][j]	

				
	print ("  Raw fractal values range: "+str(round(minvalue,2)) + " - "+ str(round(maxvalue,2)))  #+", avg: "+str(avgvaluesum/count))

	#ordering all pixel values
	allpx=[]
	for i in range(0,length,2):
		for j in range(0,length,2):
			allpx.append(px_array[i][j])
	allpx=sorted(allpx)

	lowvalue =allpx[int((lowcropprc/100.0)*len(allpx))]   #this and everything below will be water at level 0
	highvalue=allpx[int(((100-highcropprc)/100.0)*len(allpx))]   #this and all above will be top on level 60
	print ("  Cropping top and bottoms at: "+str(round(lowvalue,2))+ " / "+str(round(highvalue,2)))


	lowcount=0
	hightcount=0
	avgvaluesum=0
	count=0.0
	#recalculating image
	for i in range(length):
		for j in range(length):	
		
			if px_array[i][j]>highvalue:
				highcount+=1
				px_array[i][j]=1
			elif px_array[i][j]<lowvalue:
				lowcount+=1
				px_array[i][j]=0
			else:
				#print (str(px_array[i][j])+ " to")
				px_array[i][j]=(px_array[i][j]-lowvalue)/(highvalue-lowvalue)
				#print (str(px_array[i][j]))
				avgvaluesum+=px_array[i,j]  #=math.pow(px_array[i,j],1.3)   #gamma
				count+=1

	avg=float(avgvaluesum)/count

	print ("  Average of non-limit pixels: "+str(round(avg,3))+", image split: "+str(lowcount) +" / "+str(count)+" / "+str(highcount))


	gamma=1
	avgvaluesum=0
	count=0.0
	if avg<minavg:
		gamma=(avg/minavg)**2
		#applying gamma
		for i in range(length):
			for j in range(length):
				if  px_array[i][j]<1 and  px_array[i][j]>0:
					px_array[i][j]=pow(px_array[i][j],gamma)
					avgvaluesum=avgvaluesum+px_array[i][j]
					count+=1
	elif avg>maxavg:
		gamma=(avg/maxavg)
		#applying gamma
		for i in range(length):
			for j in range(length):
				if  px_array[i][j]<1 and  px_array[i][j]>0:
					px_array[i][j]=pow(px_array[i][j],gamma)
					avgvaluesum=avgvaluesum+px_array[i][j]
					count+=1						
	if count>0:
		print ("  applying gamma: "+ str(round(gamma,2))+"(if needed), new average:"+str(round(float(avgvaluesum)/count,2)))


	#verifying the results the image, calculating minvalue and maxvalue
	minvalue=10
	maxvalue=-10
	for i in range(length):
		#print(str(i)+" : "+str(px_array[i]))
		for j in range(length):
			if  px_array[i][j]<minvalue:
					minvalue=px_array[i][j]
			if  px_array[i][j]>maxvalue:
					maxvalue=px_array[i][j]				
				
	print ("  Modified image value range: "+str(minvalue) + " - "+ str(maxvalue))
	

	#output as jpg image
	P1R=0   #grass
	P1G=70
	P1B=0
	P2R=61  #light green
	P2G=114
	P2B=61
	P3R=112   #light brown
	P3G=112
	P3B=76
	P4R=56 #dark brown
	P4G=55
	P4B=5
	P5R=210
	P5G=209
	P5B=203	
	
	for i in range(length):
		#print(str(i)+" : "+str(px_array[i]))
		for j in range(length):
			if px_array[i][j]==-100:
				print ("unpopulated pixel")
				exit()
			value=px_array[i][j]*255
			if value<=0:
				finalR=0
				finalG=115
				finalB=232	
			elif value<60:
				finalR,finalG,finalB = new_RGB(0,60,value,P1R,P1G,P1B,P2R,P2G,P2B)
			elif value<130:
				finalR,finalG,finalB = new_RGB(60,130,value,P2R,P2G,P2B,P3R,P3G,P3B)
			elif value<215:
				finalR,finalG,finalB = new_RGB(130,215,value,P3R,P3G,P3B,P4R,P4G,P4B)
			else:
				finalR,finalG,finalB = new_RGB(215,255,value,P5R,P5G,P5B,255,255,255)
		
			newImage.putpixel((i,j),(int(finalR),int(finalG),int(finalB)))
	
	newname="Terrain_"+str(k+1)+".jpg"
	newImage.save(newname,quality=98)
	
	
	#output to file
	filename="import_coordinates_"+str(k+1)+".txt"
	f = open(filename, 'w')
	for i in range(map_size):
		x=round(float(i)/map_size*length)
		#print (" calculating : " +str(i) + "->"+str(x))
		for j in range(map_size):
			offset=0
			if j%2==1: 
				offset=0.5
			y=round(float(j+offset)/map_size*length)
			if px_array[x][y]==0:
				value=0
			else:
				value=min ((px_array[x][y]*60.0)+1 , 60)
				value=max(value,0)
				value=int(value)
			f.write(str(i)+" "+str(j)+" "+str(value)+'\n')
		f.write (' \n')
	f.close
	
	k=k+1