[Karte] - Highmaps erstellen

Für die nächste Version meines Spiels möchte ich dem Spieler eine optisch ansprechendere Karte anbieten. Sie soll aus einem großem Bild bestehen, von dem immer nur ein kleiner Teil zu sehen ist.
Ich habe mir ein Programm geschrieben, das mir aus einer Highmap (einem Graustufenbild) und 5 Grundtexturen (Wüste, Gras, Wald, Stein1, Stein2) eine geeignete Karte generiert.
Mit dem Ergebnis bin ich schon sehr zufrieden, jedoch ist meine Highmap eher schlecht als recht gezeichnet.
Kennt ihr vielleicht geeignete Programme, mit denen man schöne Highmaps erstellen kann? Sie sollte nicht zufällig generiert werden. Ich möchte die Gebirgszüge andeuten können, Programm sollte dann nach diesem groben Muster eine Highmap generieren.
Anbei der Quelltext (Java und schnell heruntergeschrieben):

/**
* Cormamap-Generator
* Michael Hilus
*/
import java.io.*;
import java.awt.*;
import java.awt.image.*;
import javax.imageio.*;
class Cormamap {
public static void main (String [] args) throws Exception {
System.out.println("Cormamap-Generator 0.3");
// Kartengröße festlegen
int mapSize = 1024;
int texSize = 256;
// Grenzen der Texturen festlegen
int g1=0,
g2=15,
g3=40,
g4=106,
g5=148,
g6=190,
g7=255;
// Heighmap laden
System.out.print(" - Highmap wird geladen...");
BufferedImage highmap = ImageIO.read(new File("highmap01.gif"));
System.out.println(" fertig.");
// Texturen laden
System.out.println(" - Texturen werden geladen...");
System.out.println(" > (gras.gif)");
BufferedImage gras = ImageIO.read(new File("textures/gras.gif"));
System.out.println(" > (stone01.gif)");
BufferedImage stone1 = ImageIO.read(new File("textures/stone01.gif"));
System.out.println(" > (stone02.gif)");
BufferedImage stone2 = ImageIO.read(new File("textures/stone02.gif"));
System.out.println(" > (desert.gif)");
BufferedImage desert = ImageIO.read(new File("textures/desert.gif"));
System.out.println(" > (forest.gif)");
BufferedImage forest = ImageIO.read(new File("textures/forest.gif"));
System.out.println(" fertig.");
// Leere Karte erzeugen
System.out.print(" - leere Karte wird erzeugt...");
BufferedImage map = new BufferedImage(mapSize, mapSize, BufferedImage.TYPE_INT_ARGB);
Graphics2D mapG = map.createGraphics();
System.out.println(" fertig.");
// Neue Karte generieren
System.out.print(" - neue Karte wird generiert...");
for(int y=0; y
for(int x=0; x
// Koordinaten der Texturen
int tx = x%texSize;
int ty = y%texSize;
// Farben Highmap
int rh = new Color(highmap.getRGB(x,y)).getRed();
int gh = new Color(highmap.getRGB(x,y)).getGreen();
int bh = new Color(highmap.getRGB(x,y)).getBlue();
// Farben Wüste
int rd = new Color(desert.getRGB(tx,ty)).getRed();
int gd = new Color(desert.getRGB(tx,ty)).getGreen();
int bd = new Color(desert.getRGB(tx,ty)).getBlue();
// Farben Gras
int rg = new Color(gras.getRGB(tx,ty)).getRed();
int gg = new Color(gras.getRGB(tx,ty)).getGreen();
int bg = new Color(gras.getRGB(tx,ty)).getBlue();
// Farben Wald
int rw = new Color(forest.getRGB(tx,ty)).getRed();
int gw = new Color(forest.getRGB(tx,ty)).getGreen();
int bw = new Color(forest.getRGB(tx,ty)).getBlue();
// Farben Stein1
int rs1 = new Color(stone1.getRGB(tx,ty)).getRed();
int gs1 = new Color(stone1.getRGB(tx,ty)).getGreen();
int bs1 = new Color(stone1.getRGB(tx,ty)).getBlue();
// Farben Stein2
int rs2 = new Color(stone2.getRGB(tx,ty)).getRed();
int gs2 = new Color(stone2.getRGB(tx,ty)).getGreen();
int bs2 = new Color(stone2.getRGB(tx,ty)).getBlue();
double r, g, b;
r = rd*topo(g1, g2, g3, rh) +
rg*topo(g2, g3, g4, rh) +
rw*topo(g3, g4, g5, rh) +
rs1*topo(g4, g5, g6, rh) +
rs2*topo(g5, g6, g7, rh);
g = gd*topo(g1, g2, g3, gh) +
gg*topo(g2, g3, g4, gh) +
gw*topo(g3, g4, g5, gh) +
gs1*topo(g4, g5, g6, gh) +
gs2*topo(g5, g6, g7, gh);
b = bd*topo(g1, g2, g3, bh) +
bg*topo(g2, g3, g4, bh) +
bw*topo(g3, g4, g5, bh) +
bs1*topo(g4, g5, g6, bh) +
bs2*topo(g5, g6, g7, bh);
int c = new Color((int)r, (int)g, (int)b).getRGB();
map.setRGB(x, y, c);
}
}
mapG.dispose();
System.out.println(" fertig.");
// Map speichern
System.out.print(" - neue Karte wird gespeichert...");
ImageIO.write( map, "png", new File("newmap.png") );
System.out.println(" fertig.");
}
public static double topo(int l, int m, int r, int x) {
double topo=0;
x = 255-x;
if(x
topo = (double)(x - l)*(1.0 / (double)(m-l));
else
topo = 1.0 - (double)(x - m)*(1.0 / (double)(r-m));
if(topo<0) topo=0;
if(topo>1) topo=1;
if((l==0) && (x
if((r==255) && (x>m)) topo=1.0;
return topo;
}
}

Ich dachte da eher an weniger kostenspielige Programme. Oder gibt es auch eine Studentenversion von Photoshop?

Vielleicht hilft dir Paint mit Airbrush-Funktion?
Ansonsten verweise ich mal auf die üblichen verdächtigen:
- Paint.net
- TheGimp
Von Photoshop gibts ne Studentenversion, die übersteigt das Budget fast aller Studenten trotzdem um ein vielfaches.

Paint mit Qirbrush hab ich schon versucht und das Resultat war eine Katastrophe
Aber Gimp und Paint.net schau ich mir mal an.
Danke für die schnelle Antwort.

Mal eine Schwarz/Weiss Grafik, in der die paar Weissen stellen deine angedeuteten Berge darstellen. Mit dieser Karte dann in vielen Iterationen :
- Glätten : Neuen Punkt mit Hilfe der alten Werte einiger Nachbarn und sich selber berechnen
- zufällige Störung einfügen
- Normalisieren
Sollte eigentlich ausreichend gute Ergebnisse ergeben.