Describe Basic_tiling here.

Basic tiling is how we increase resolution. This procedure is based on using bigmap. You can also tile using Lat/Lon LatLon_tiling.

The setup for tiling requires creating an updated

bigmap file

make_scriptT.in file.

Making the bigmap

The first step to to make a bigmap. This provides the basic (and hopefully improved) topography that the new landmarks will be tiled to. We also use it for the coordinate frame of reference which lithos will use when building landmarks.

In general, we create an input file that is fed into bigmap that has the parameters that we want. The user must adjust the bigmap scale in order to achieve the desired maplet overlap percentage, please refer to the Basic Tiling - Achieving the Desired Maplet Overlap guide.

An example of the input file is a file called bigEq4.in that I store in the support directory (it can be whatever name you want).

l 0.000 180.00 0.0003000 500 1.23400 1000EQUAT41.005.02510011111100

You use this set of input values as standard input (stdin) for bigmap as such:

/usr/local/bin/bigmap < support/bigEq4.in

bigmap will run and create a bigmap with the standard MAPLET format. It will be created in MAPFILES directory and called EQUAT4.MAP (or whatever 6 character name you gave on line 4 of your input file). bigmap will also display the name of the bigmap created. Additionally, it will add the filename into the file BIGLIST.TXT. You can look at this file (the .MAP file? JRW) by using the program show_map

/usr/local/bin/SHOWMAPEQUAT4/opt/local/bin/convert EQUAT4.pgm lookatme.jpg

Now that you have the bigmap, let's use it using a standard name. Bob likes to use XXXXXX for general scripts and inputs. If you see an XXXXXX-anything, you know it is temporary and you don't need to save it.

cp -f MAPFILES/EQUAT4.MAP MAPFILES/XXXXXX.MAP

Creating the make_scriptT.in file

To create the make_scriptT.in file, you must do several things. In summary, you will be

Running map_coverage to figure out where there are already existing maplets. It creates coverage_m.pgm.

Running make_tilefiles to get a list of X/Y coordinates for the new maplets. It reads coverage_m.pgm.

Deleting the user prompt

Create a new make_scriptT.in file that has

Coordinate reference system or bigmap name

Name of the seed file

list of coordinates

Keyword "END"

1 -- Running map_coverage.e

map_coverage will look at the boundaries of the specified bigmap and figure out where all the landmarks are in it. It makes a display image, coverage_m.pgm, that shows the footprint of each maplet with increasing intensity for overlaps. Note - this program does not give you a prompt.

You give it 3 values:

bigmap name

min resolution (in km), usually 0

max resolution to display (in km), usually the resolution that you will be building your new maplets at

This will show all the 75cm maplets (and smaller) that fall within the bigmap EQNOR1

/usr/local/bin/map_coverageEQNOR10 .00075

You can see the where the current maplets are by looking at the file.

/opt/local/bin/convert coverage_m.pgm lookatme.jpg

open -a GraphicsConverter coverage_m.pgm

/opt/local/bin/display coverage_m.pgm

/opt/local/bin/convert converage_m.pgm /Library/WebServer/Documents/data/lookatme.jpg (and viewing on the web server)

2 -- Running make_tilefile.e

make_tilefile reads the output image coverage_m.pgm. It will create an X/Y coordinate pair every 50 pixels while skipping location that already have maplets. This program wants you to tell it if it should sort largest to smallest or smallest to largest -- it doesn't matter. The tricky part of this is that the output needs to be put into a file, and if you do this, you won't see the prompt. One way to avoid this is to just use the echo command to send the standard input value needed to the program directly. For this example, I will use the temporary file "out".

echo "N" | make_tilefile > out

The file "out" will look like this

Upwards? (y/n) 50 950 100 950 150 950 200 950 250 950 300 950 350 950...END

3 -- Deleting the user prompt

Now, you need to edit the file to remove the top line -- the one that says, "Upwards? (y/n)".

Thus, the file "out" should end up looking like

50 950 100 950 150 950 200 950 250 950 300 950 350 950...END

4 -- Cobble together a new make_scriptT.in file

You may have an existing make_scriptT.in file, but you won't need it. Delete it. You need to figure out the name of your seed file. Usually, it is XX0150.SEED or something similar. The numbers usually indicate the resolution of the maplets it will build. In this case, we will use XXX075.seed and the seed file (that has all the lithos commands to make the maplet). Obviously, you change what I am using with whatever filename your seed file has.

echo "XXXXXX" > make_scriptT.inecho "XXX075.seed" >> make_scriptT.incat out >> make_scriptT.in

(YES -- the first one is a single >, while the rest are >>)

Your make_scriptT.in file should look like this.

XXXXXXXXX075.seed 50 950 100 950 150 950 200 950 250 950 300 950 350 950 400 950 ...END

Running the tiling process

First, let's clean up stuff from previous runs (you may not need to do this)

sh rem_script.brm -f TESTFILES/*rm -f TESTFILES1/*

Second, we run make_scriptT, which makes all of the input files needed (001.INN, 002.INN, etc.)

make_scriptT

If you do an 'ls' you can see that you made a bunch of them. You can also check what they have in them. Just do a "more 001.INN" and see that it has commands for lithos

Third, run the script. I use the "nohup" command to ensure the job doesn't stop just because my login shell is killed.

nohup sh run_script.b &

Fourth, monitor it.

Use the command find_nofitT to see which maplets need human attention. If the maplet doesn't get enough images, lithos will just delete it -- that's okay. If there is a big error, the maplet name will be listed with a "*". The other flags are not important right now because it is likely they will go away with additional processing.

Bob's procedure for tiling:TILE_MAP.TXT

..........................................TILING OF REFERENCE MAP..........................................# Make bigmap REFMAP with scale = 1.25*ms (ms=maplet scale):/usr/local/bin/BIGMAP.. INPUTS ..REFMAP1.005.0251111100/usr/local/bin/SHOWMAPREFMAPgc REFMAP.pgm/usr/local/bin/map_coverageREFMAPms,ms/usr/local/bin/make_tilefile# For make_scriptT.in use:& cp MAPFILES/REFMAP.MAP MAPFILES/XXXXXX.MAPXXXXXXXXSEED.SEED[output of make_tilefile]cp USED_MAPS.TXT LMRKLISTO.TXT./rem_script.brm -f ./TESTFILES/*rm -f ./TESTFILES1/*/usr/local/bin//make_scriptTchmod +x run_script.bnohup ./run_script.b &# Monitor with:/usr/local/bin/find_nofitT# remove LMRKLISTO.TXT when done:rm -f LMRKLISTO.TXT

map_coverage ms, ms in the instructions above are in km. So for 75 cm input is 0, 0.00075.

Tiling over difficult objects

Here is a naming scheme to keep everything de-conflicted. Assumes you start tiling at 18cm, then go to 9cm, 4.5cm, 2.23cm, and stop at 1.25cm. It is based off base 4 math.

Namingschemepic; Naming_scheme.