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

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        1000
EQUAT4
1
.005
.025
1
0
0
1
1
1
1
1
1
0
0

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/SHOWMAP
EQUAT4
/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

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

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

  3. Deleting the user prompt
  4. 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:

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

/usr/local/bin/map_coverage
EQNOR1
0 .00075

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

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.in
echo "XXX075.seed" >> make_scriptT.in
cat out >> make_scriptT.in

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

Your make_scriptT.in file should look like this. 

XXXXXX
XXX075.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.b
rm -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 ..
REFMAP
1
.005
.025
1
1
1
1
1
0
0
/usr/local/bin/SHOWMAP
REFMAP
gc REFMAP.pgm

/usr/local/bin/map_coverage
REFMAP
ms,ms
/usr/local/bin/make_tilefile

# For make_scriptT.in use:

& cp MAPFILES/REFMAP.MAP MAPFILES/XXXXXX.MAP
XXXXXX
XXSEED.SEED
[output of make_tilefile]

cp USED_MAPS.TXT LMRKLISTO.TXT

./rem_script.b
rm -f ./TESTFILES/*
rm -f ./TESTFILES1/*
/usr/local/bin//make_scriptT
chmod +x run_script.b
nohup ./run_script.b &

# Monitor with:

/usr/local/bin/find_nofitT

# remove LMRKLISTO.TXT when done:

rm -f LMRKLISTO.TXT

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.

Basic_tiling (last edited 2016-01-15 15:46:04 by DianeLambert)