Notes, Day 4 - SPC Wiki

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)

M595949305F0
M595949731F0
M595950157F0
M595950583F0
M595951436F0
M595952715F0
M595953994F0
M595956978F0
M595957405F0
M595959536F0
M595960815F0

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

XXXXXX
scripts/XXX075.SEED
      50  150
     100  150
     150  150
      50  100
     100  100
     150  100
      50   50
     100   50
     150   50
END

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_coverage
MTAG15
0 .00075
convert coverage_m.pgm 75.jpg; open 75.jpg
map_coverage
MTAG15
0 .00015
convert 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        1000
POLE00
1
.005
.025
1
1
1
1
1
1
1
0
0