Autoregister

autoregister adds landmarks to one image at a time. Contrast that with lithos that adds images to landmarks.

Once you have a model, you will use autoregister to add images to the shape model. You will do this every time new images are collected.

autoregister does not update the topography itself. You still need to do an iteration to use the new images to build a template and generate topography.

When you accept the auto-alignment, SPC will update the spacecraft position and pointing. This is the same as running geometry, option 2.

Look at the LMRK_DISPLAY1.pgm.

How do the image/shape pair look.

Any issues?

If so, you may have to fix them.

Autoregister the new MapCam images of the north pole. Do the following images (you registered these yesterday)

M595949305F0M595949731F0M595950157F0M595950583F0M595951436F0M595952715F0M595953994F0M595956978F0M595957405F0M595959536F0M595960815F0

Basic autoregister cookbook:

autoregister

<imageName>

y - add images

0.5

n

n - eliminate new

0,50,.25,0,5 - criteria (notice there is one fewer parameter)

1 - auto align

2 - spacing

n - no new spacing

0 - continue

y - accept changes (this will update the spacecraft pointing and position)

1 - auto align

1 - spacing

n - no new spacing

0 - continue

y - accept changes (this will update the spacecraft pointing and position)

o - eliminate by correlation

.5 - Correlation value

1 - auto align

1 - spacing

n - no new spacing

0 - continue

y - accept changes (this will update the spacecraft pointing and position and only use the remaining correlated images)

4 - change flags

b - use all (this sets each image to be used when building a template)

0 - end

q

END

Tile a bigmap

Here you will tile the TAG site (Touch and Go site - where the spacecraft is planning on collecting a sample). We will do this in batch mode using make_scriptT. This uses a bigmap of the TAG site. The routine will put a new maplet every 50 pixels within the bigmap, and when it is done, it will have tile the entire area with a 30% overlap.

Key differences between tiling using a bigmap and tiling using lat/lon

The position definition is based upon a reference bigmap

We use the topography of the bigmap

Name this file scripts/make_scriptT_bigmap.in

XXXXXXscripts/XXX075.SEED 50 150 100 150 150 150 50 100 100 100 150 100 50 50 100 50 150 50END

Cookbook for this task:

Create the make_scriptT_bigmap.in in the scripts directory

Make a symbolic link

ln -s scripts/make_scriptT_bigmap.in make_scriptT.in

Copy the TILE00.MAP file into your MAPFILES directory. Normally, you'd create this yourself, but to save time and make things straight forward, I created it for you. It is almost exactly like the bigmap MTAG15 that you created yesterday, but the resolution has been selected to make correctly spaced maplets. TILE00.MAP

Make a symbolic link from TILE00.MAP to XXXXXX.MAP in the MAPFILES directory

cd MAPFILES ln -s TILE00.MAP XXXXXX.MAP

Double check all of your files.

Running showmap on XXXXXX is a useful way to check that you have the right map installed.

head make_scriptT.in head scripts/XXX075.SEED echo XXXXXX | showmap convert XXXXXX.pgm xxxxxx.jpg; open xxxxxx.jpg

In the working directory, run make_scriptT

Review the output.

You should see nine INN files.

Check the file to see that it is correct

Run the run_script.b and monitor

make_scriptT nohup sh run_script.b & find_nofitT

When complete, rebuild the bigmap MTAG15

bigmap < lsupport/MTAG15.in echo MTAG15 | showmap convert MTAG15.pgm mtag15.jpg; open mtag15.jpg

Check the create coverage of the newly created maplets using map_coverage.

The first time, we are looking only at the 75m landmark.

The second time, it is showing all landmarks (technically all landmarks between 0 and 150cm).

map_coverageMTAG150 .00075convert coverage_m.pgm 75.jpg; open 75.jpgmap_coverageMTAG150 .00015convert coverage_m.pgm 150.jpg; open 150.jpg

Iterate over the North Pole

To get the benefit of the new images, we need to run an iteration (like we did yesterday). However, we don't need to run it over the entire surface (it wouldn't hurt, but to save time, we will focus).

Create a bigmap over the pole - see file below

bigmap < lsupport/POLE00.in echo POLE00 | showmap convert POLE00.pgm pole.jpg; open pole.jpg

Copy USED_MAPS.TXT to LIST.TXT

cp -f USED_MAPS.TXT LIST.TXT

Run duplicates to generate the make_script.in

duplicates

Re-generate LMRKLISTX.TXT

MAKE_LMRKLISTX

Generate the scripts

make_scriptP > run.sh cat run.sh

Check the setup (ensure everything is ready)

make_script.in

make_scriptP.seed

directory is clean

LMRKLISTX.TXT is current (i.e. it has all the landmarks)

run.sh has been created

run_script01/02/03/04 are all ready

TESTFILES and TESTFILES1 are empty

Launch the iteration

nohup sh run.sh

Review the progress

find_nofitP # shows how many landmarks have been done

tail -f *OOT # lists the output.

It will show you output as it is generated (can have a long delay)

top -o cpu

# This shows the processes that are using lots of CPUs

Note, if the cpu is working hard, but you are not making any new OOT files, it could be that there is a file lock in TESTFILES that is blocking everyone from running.

You can do ls -l TESTFILES to see how old the file is.

If it is more than 5 minutes old, then the process that created it has died without removing it.

You can delete this file, but be aware that the situation that caused the first process to die may still be there)

One benefit of using run.sh is that it makes it easier to kill the system if you've made a mistake

ps ax | grep LITHOSP

You see a list of four processes.

If you kill one of them, the next data set in the list will start.

The output will also tell you what it's process id (pid) is.

ps ax | grep run.sh

This will list the parent process.

If you kill it, then no new LITHOS programs will be launched.

Also, it will let LITHOS finish running, so the landmark isn't left in an undetermined state (such as a file partially written)

kill <pid> # This kills the program

kill -STOP <pid> # This suspends the process. This is useful to pause the work (especially if you need to run residuals.

kill -CONT <pid> # This lets the process continue.

Create the file POLE00.in in lsupport (or where every you want)

l 88.000 262.768 0.000500 200 1.23400 1000POLE001.005.025111111100