Dyne: Note about

2008-04-30T14:31:13Z

Note about

Dyne: Terrain splitting script

2008-04-30T13:46:27Z

Terrain splitting script

New page

I am posting this here for the time being; it will probably eventually be put somewhere else in the User Docs section.

Below is a python script that takes one or more images (usually greyscale terrain maps, large enough for multiple sims) and splits them into sim-sized tiles. The tiles will be inverted along the Y axis to match OpenSim's axes (you could do this from L3DT, but I find it nicer to have a correctly-oriented full map handy).

Copy the script into your text editor and name the thing terrain-split.py (or whatever). Note that it requires that the [http://www.pythonware.com/products/pil/ Python Imaging Library] be installed, or it won't work.

===Usage===

Assuming that your input is a 512x512 pixel image at the following path (relative to the where you invoke the script):

:mysims/multisim.png

Then you'd run it like:

:<code>python terrain-split.py mysims/multisim.png</code>

This will do one of two things, depending on the value of the <code>__interactive__</code> variable (I haven't made that into a nice commandline switch yet). If it is 0, then the script will spit out these files (along with some text output):

* mysims/multisim.0.1.png (the northwest piece)
* mysims/multisim.1.1.png (the northeast piece)
* mysims/multisim.0.0.png (the southwest piece)
* mysims/multisim.1.0.png (the southeast piece)

The numbers there are intended to aid you in picking grid positions for those sims. You choose a grid position for the lower left/southwest sim ... say (1575, 634). Then, for each sim, just add those two numbers to the base grid X and Y respectively:

* NW: 1575, 635
* NE: 1576, 635
* SW: 1575, 634
* SE: 1576, 634

If the <code>__interactive__</code> variable is set to 1, the script will be slightly nicer and ask you for the base grid coordinate (always for the sim in the lower left corner) and then the name of each sim as it processes it. If I used the same input file and base coordinates as above, and named the above sims "alice", "bob", "charles", and "dan", then it'd spit out these files:

* mysims/alice.1575.635.png
* mysims/bob.1576.635.png
* mysims/charles.1575.634.png
* mysims/dan.1576.634.png

The tilesize is defined in the script (256 pixels by default, to match the required size for a sim texture at present). The script will take images of arbitrary size (so you could use a 768x1024 input, which will produce 12 sims, in 3 rows and 4 columns), but any pixels along the right or bottom edges that aren't large enough to be a full tile will get ignored. You can also specify multiple input files, and it'll loop through them one by one.

I left the noninteractive mode in, just in case someone wanted to use this in a more automatic fashion.

This has ''not'' been fully tested, so there may well be stupid bugs.

===Script===
<code><pre><nowiki>#!/usr/bin/python
'''This simple script takes the filename of an image that is a multiple of the tilesize (256 by default), and splits it into tiles of that size.

USAGE: python terrain-split.py infile1 [infile2 ... infileN]

Note that any extra pixels in the original image beyond an even multiple of the tilesize are ignored.
'''

__interactive__ = 1

import Image, ImageOps
import os.path, sys

tilesize=256

for infile in sys.argv[1:]:
try:
myimage = Image.open(infile)
path, filename = os.path.split(infile)
basename, extension = os.path.splitext(filename)
(width,height) = myimage.size
tileswide = width // tilesize
tileshigh = height // tilesize
twremain = width % tilesize # leftover pixels
thremain = height % tilesize # leftover pixels

print
print "---------------------------------------------------------"
print "Input file: " + infile
print "Image dimensions: %s x %s pixels" % (width,height)
print "Output: %s x %s tiles (%s files) of %s pixels square" % (tileswide, tileshigh, tileswide*tileshigh, tilesize)
print "Pixels truncated: %s across, %s down" % (twremain, thremain)
if __interactive__:
print
print "Note: Values in [brackets] are defaults."
print
xin = raw_input("What is the desired grid X coordinate of the lower-left sim [1000]? ")
if xin == "":
basegridX = 1000
else:
basegridX = int(xin)
yin = raw_input("What is the desired grid Y coordinate of the lower-left sim [1000]? ")
if yin == "":
basegridY = 1000
else:
basegridY = int(yin)
for y in range(tileshigh):
print
print "Tiling Row #%s" % str(y+1)
for x in range(tileswide):
# Compute the upper left corner
xnew = x * tilesize
ynew = y * tilesize
yrelative = tileshigh-y-1

# Decide how to name the file
if __interactive__: # the filename will be based on individual names and will include the actual grid coordinates
nameprompt = "What is the name of the sim at row %s, column %s [%s]? " % (y+1, x+1, basename)
simname = raw_input(nameprompt)
if simname == "":
simname = basename
newfile = simname + "." + str(x + basegridX) + "." + str(basegridY+yrelative) + extension
else: # the filename of our output tile is based on the input file and includes relative positions
newfile = basename + "." + str(x) + "." + str(yrelative) + extension
outfile = os.path.join(path, newfile)

# Create the tile
# Flip the tile along the way (transpose) to account for inverted Y axis.
borders = (xnew, ynew, xnew+tilesize, ynew+tilesize)
tile = Image.new("RGB", (tilesize, tilesize))
region = myimage.crop(borders).transpose(Image.FLIP_TOP_BOTTOM)
tile.paste(region, (0,0) )

# Attempt to save it
try:
tile.save(outfile)
print "Writing: File %s with coords %s - %s" % (outfile, (xnew,ynew), (xnew+tilesize-1, ynew+tilesize-1) )
except IOError:
print "Cannot open output file ", outfile
except IOError:
print "Cannot open file ", infile
print "---------------------------------------------------------"</nowiki></pre></code>

← Older revision		Revision as of 14:31, 30 April 2008
Line 3:		Line 3:

	Below is a python script that takes one or more images (usually greyscale terrain maps, large enough for multiple sims) and splits them into sim-sized tiles. The tiles will be inverted along the Y axis to match OpenSim's axes (you could do this from L3DT, but I find it nicer to have a correctly-oriented full map handy).		Below is a python script that takes one or more images (usually greyscale terrain maps, large enough for multiple sims) and splits them into sim-sized tiles. The tiles will be inverted along the Y axis to match OpenSim's axes (you could do this from L3DT, but I find it nicer to have a correctly-oriented full map handy).
		+
		+	This basically does the same thing as <code>script terrain load-tile</code>, but since I wanted to use [http://www.spinmass.com/bailiwick Bailiwick] to fiddle with the channels of the sim, and it doesn't take multi-sim input files, I needed to do it a different way. Hopefully this will be useful.

	Copy the script into your text editor and name the thing terrain-split.py (or whatever). Note that it requires that the [http://www.pythonware.com/products/pil/ Python Imaging Library] be installed, or it won't work.		Copy the script into your text editor and name the thing terrain-split.py (or whatever). Note that it requires that the [http://www.pythonware.com/products/pil/ Python Imaging Library] be installed, or it won't work.

User:Dyne - Revision history

Dyne: Note about

Dyne: Terrain splitting script