Squeeze the most out of Vr with Python

We all have our limits

2009-05-18T07:16:00.008-05:00

Note that I am trying a new method of posting code, hope it works better but of course the original code itself can always be downloaded from the website where it is stored.

Quite often when writing some sort of import function I would like to limit the data imported to certain physical constraints. I started out asking the user if they want to only act on coordinate values that fall within a bounding box, then if they said yes, prompt them to ID the bounding line. This works great as far as it goes, as part of the ID function I would set a flag (in this case BoundrySet) to 1 then later in the program if BoundrySet was true the IsPointInside method of the Line class could be called. Something like....

if BoundrySet :
if BoundingLine.IsPointInside (X,Y): Do something

But then I got thinking, there are several easy ways to check for bounding areas without having a line already digitized. How about using the screen boundaries, or digitizing a rectangle based on the lower left and upper right corners, or for that matter just start digitizing points and create a line in memory on the fly. Well it turns out that I already had the snippets I needed in other functions so just copied them out, cleaned them up a bit (and I do mean a bit, it still isn't particularly pretty, but it works) and created a basic function that I can paste into any program where spatial filtering is helpful.

There are a couple of caveats. Using the rectangle select mode requires that you select the lower left point first, then the upper right based on the screen orientation. I'll probably clean this up some day and allow for more flexibility but it falls into the "quick hack for some purpose, and I know how it acts" category of code that gets the job done but isn't as attractive as it should be. Using the "Digitize" mode allows the user to start clicking on positions and builds the boundary line on the fly, if it would be helpful it would be just as easy to record the line for future interaction but for now I just throw it on the screen. The nice thing about this dialog is that it behaves just the way you expect so if the focus is in the drop down and you hit an 'r' rectangle mode will be activated and so on.

print 'SetBoundary.py modified 8:00 AM 5/15/2009'
# Set spatial bounding for processing
'''
Copyright 2009 Dennis Shimer, M.A.N. Mapping Services Inc.
No warranties as to safety or usability expressed or implied.
Free to use, copy, modify, distribute with author credit.

Really just a container for the code snippet that would do spatial
filtering as part of a larger program. Just written as working code
here for testing purposes.

Variables of interest:
None
'''
import math

BoundingLine=PyVrLine()
Gr=PyVrGr ()
Gui=PyVrGui()
BoundrySet=0

PromBox = VrPromBox ("Set Boundry", 30, 1)
PromBox.AddCombo ('Boundry', 5, 0, 0)
PromBox.AddComboItem ('Line')
PromBox.AddComboItem ('Screen')
PromBox.AddComboItem ('Rectangle')
PromBox.AddComboItem ('Digitize Points')
PromBox.AddComboItem ('None (whole file)')
PromBox.SetFocus()
if PromBox.Display(1)==0:
BoundryType=PromBox.GetComboByPrompt ('Boundry')
if BoundryType==0:
   BoundingLine.Id()
   BoundrySet=1
elif BoundryType==1:
   for corner in range(4):
       x,y,z=Gr.GetWinCorner (corner,0)
       BoundingLine.AddPoint(x,y,z)
   BoundrySet=1
elif BoundryType==2:
   Stat,llx,lly,z=Gui.GetCoord('Boundry')
   Gr.DrawMode (1,-1)
   Gr.PenNum (1)
   Gr.DrawMarker (llx,lly,z,MARK_CROSS,Gr.GetWinScale ()*.2,-1)
   Stat,urx,ury,z=Gui.GetCoord('Boundry')
   Gr.EraseMarker ()
   ScreenAngle=Gr.GetWinRot()[2]
   Angle=math.atan((ury-lly)/(urx-llx))-Gr.GetWinRot()[2]
   Diagonal=PyVrGeom().Dist(llx,lly,urx,ury)
   Height=math.sin(Angle)*Diagonal
   if Height < 0.0: Height=Height*-1.0
   Width=math.cos(Angle)*Diagonal
   if Width < 0.0: Width=Width*-1.0
   BoundingLine.AddPoint(llx,lly,z)
   lrx=llx+(Width*math.cos(ScreenAngle))
   lry=lly+(Width*math.sin(ScreenAngle))
   BoundingLine.AddPoint(lrx,lry,z)
   urx=lrx-(Height*math.sin(ScreenAngle))
   ury=lry+(Height*math.cos(ScreenAngle))
   BoundingLine.AddPoint(urx,ury,z)
   ulx=urx-(Width*math.cos(ScreenAngle))
   uly=ury-(Width*math.sin(ScreenAngle))
   BoundingLine.AddPoint(ulx,uly,z)
   BoundingLine.AddPoint(llx,lly,z)
   BoundingLine.Plot()
   BoundrySet=1
elif BoundryType==3:
   Stat=0
   while Stat==0:
       Stat,x,y,z=PyVrGui().GetCoord('Dig Boundry')
       BoundingLine.AddPoint (x,y,0.0)
       BoundingLine.Plot()
   BoundingLine.Close(2)
   BoundingLine.Plot()
   BoundrySet=1

The 5 minute function.

2009-04-29T06:49:00.002-05:00

No I'm not actually going to put a lot of time into a post since there doesn't really seem to be much interest in what's going on. However a recent conversation in the Vr Python Forum is a perfect example of the whole purpose of having Python in Vr. If you are a member you can check it out there.

http://www.cardinalsystems.net/forum/index.php?topic=51.0

The basic premise is that you need a simple function to automate a fairly simple task, in this case labeling all symbols in specified layers with a piece of text in which the label is the symbols feature code. It could be any attribute, or any entity type, but the point is; rather than waiting for the feature to show up in Vr, with a little practice, you can write it yourself (usually from existing snippets) in about 5 minutes and be on your way.

Inherit everything but the kitchen sink.

2007-11-01T07:33:00.000-05:00

Back when I was just a young map maker, I was actually fairly sharp, and had a memory that was quite useful. I worked on a CAD system that until VrOne came along seemed like one of the fastest, most practical, easy to use map collection systems around. It used a numeric command set that allowed you to set any combination of insert parameters to a 3 digit code. Alas you were limited to 120 codes which seemed like plenty and were quickly memorized. Of course now I can't remember what I had for breakfast (I did have breakfast didn't I), but I can remember all 120 of those codes. The flexibility of Vr allowed me to easily make macros that do those 120 tasks, but over the years we continued to add things. Now I know there is a function key that will put in a double yellow road centerline, but what combination of letters did we use for the function key (there are 26 letters and 5 unique words in that description). Sometimes when I'm collecting I think good grief, there is what I want right there, it sure would be nice to just change my current parameters to match that existing entity. Well, back in January I added a quick command that came in handy more often than I thought and has grown up since then. The premise was simple, a command that allowed you to Id a line, then start digitizing using the attributes of that line. Remember it looked something like this

Line = PyVrLine ()
Gui=PyVrGui()
Line.Id()
lay,gp,wid=Line.GetLayer(),Line.GetGpoint(),Line.GetWidth()
Gui.PushKeyin ('inslin,lay=%d,grp=%d,wid=%d'%(lay,gp,wid))

It was so handy that I made one that did the same thing for fly-lines, and symbols. This way when I'm tying to an edge or come across something I forgot, and can't remember the function key, all I need is the short mnemonics for my inhlin, inhfly, and inhsym commands. Then I got thinking, what if I'm already digitizing a line or symbol and want to match something I happen upon? Well here is my inhent.py which some folks might find a bit odd but it also gives examples of a couple of useful Vr Objects

print 'inhent.py Inherit From Entity modified 8:52 AM 10/31/2007'
'''
Copyright 2007 Dennis Shimer, M.A.N. Mapping Services Inc.
Vr Mapping copyright Cardinal Systems, LLC
No warranties as to safety or usability expressed or implied.
Free to use, copy, modify, distribute with author credit.

Asks user to identify an entity, then sets certain
parameters inherited from the identified entity.

'''

Line=PyVrLine()
Sym=PyVrSym()
Text=PyVrText()
Gui=PyVrGui()

Ws=PyVrWs()
# There are a couple of times we'll need to multiply by the scale because ground
# units are returned, and we'll need to set based on map units.
Scale=PyVrWs().GetTargetScaleIn(Ws.Aws())

EntWs,EntNum,EntType,LinePtNum,x,y,z=Ws.IdEnt(-1,-1,-1,-1)
# Man I love IdEnt, it isn't in the documentation yet but by using
# -1 in the SeaEnttype spot, it remembers the last state.
if EntType==1:
# If it's a line grab the appropriate settings
...Line.Load(EntWs, EntNum)
...Layer,Graphic,Width=Line.GetLayer(),Line.GetGpoint(),Line.GetWidth()
# This line is left over from when I forced the user to hit end after
# identifying the entity, which was useful if you grabbed the wrong one
# but I found I liked it this way better, so the following line doesn't
# really matter because it just does it after you id something.
...Gui.DspMsg0 ('lay=%d, grp=%d, wid=%d'%(Layer,Graphic,Width))
...Type='Line'
if EntType==3:
# Ditto if it's a symbol.
...Sym.Load(EntWs, EntNum)
...Layer,Graphic,Radius,Rotation=Sym.GetLayer(),Sym.GetGpoint(),(Sym.GetRad()/Scale),Sym.GetRot()
...Gui.DspMsg0 ('lay=%d, grp=%d,rad=%.3lf,rot=%.3lf'%(Layer,Graphic,Radius,Rotation))
...Type='Symbol'
if EntType==4:
# or even a piece of text.
...Text.Load(EntWs, EntNum)
...Layer,Font,Height,Width,Rotation,Label=Text.GetLayer(),Text.GetFontNum(),(Text.GetHgt()/Scale),(Text.GetWdt()/Scale),Text.GetRot(),Text.GetText()
...Gui.DspMsg0('lay=%d,fnt=%d,hgt=%.3lf,wdt=%.3lf,rot=%.3lf,txt=%s'%(Layer,Font,Height,Width,Rotation,Label))
...Type='Text'

# Once you grab the settings desired, the only thing left to do is
# push the proper key-ins.
if Type=='Line':
...Gui.PushKeyin ('lay=%d,grp=%d,wid=%d'%(Layer,Graphic,Width))
elif Type=='Symbol':
...Gui.PushKeyin ('lay=%d,grp=%d,rad=%.3lf,rot=%.3lf'%(Layer,Graphic,Radius,Rotation))
elif Type=='Text':
...Gui.PushKeyin ('lay=%d,fnt=%d,hgt=%.3lf,wdt=%.3lf,rot=%.3lf,txt=%s'%(Layer,Font,Height,Width,Rotation,Label))

Given that there probably aren't 3 people in the world that read this on a regular basis, I'll probably hit it about once a month from now on. Don't forget to contribute to the forum.

Happy coding.

Time out

2007-08-07T02:08:00.000-05:00

It is that time of year when I begin to pursue my second job as middle school soccer coach, and high school referee (and parent spectator). Because of this, I'm not even going to think about posting until late October.

Finally A Vr Command

2007-07-19T15:10:00.000-05:00

Well enough playing around with external files. It's about time to head back to what VrPython was intended for and write a new function. This one in particular allows the user to parallel part of an existing line. This is a good example of how a program evolves (to say it was intelligently designed probably infers too much), because as it started off the user had to digitize the offset distance. Then with the advent of VrArgs in 3.3.? it seemed like a good idea to put in the option to enter an offset as a argument after the user typed parpart. Of course with the opportunity to put in a argument as an offset, it seemed silly to not have a dialog somewhere. The problem was that I didn't want dialog every time, and you already had to Id the line, start point, end point, and offset which was approaching the limits of how much I wanted the user to have to do. Hence the decision that if you got all the way to the point of digitizing the offset and hadn't specified one but hit an "end" or "#" without doing so the program would bring up a dialog to allow typing one in. Well let's take a look

#This has become the standard I use to start each program.
print 'parprt.py ParallelPartial modified 8:23 AM 7/13/2007'
'''
Copyright 2007 Dennis Shimer, M.A.N. Mapping Services Inc.
Vr Mapping copyright Cardinal Systems, LLC
No warranties as to safety or usability expressed or implied.
Free to use, copy, modify, distribute with author credit.

Inserts a line parallel to the identified line.
Allows for picking start and end points of new line, and offset.
If a number is passed it as the first it will be used as an offset.
If the <#> End button is pressed during offset measurement a
dialog will come up prompting for offset.
'''

Ws=PyVrWs()
Line=PyVrLine()
Gui=PyVrGui()
WsNum=Ws.Aws()
# Create all the objects we will use.

while Line.Id() != -1:
# In theory you could partially parallel many lines
# though in reality it doesn't happen much, but will do so
# until the user doesn't Id a line which returns -1.

....Ws.UndoBegin(WsNum,"inspar_part")
# The undo is inside the Id loop so each line paralleled
# could be undone individually.

....Gui.DspMsg0('Dig start of new line')
# Since GetCoord() isn't very customizable as far as buttons
# and messages, we'll display instructions in the message area.

....Stat1,NewX1,NewY1,NewZ1=Gui.GetCoord('Point1')
# And get a coordinate for where the newly paralleled line
# Should begin.

....Gui.DspMsg0('Dig end of new line')
....Stat2,NewX2,NewY2,NewZ2=Gui.GetCoord('Point2')
# And the same on the other end.

....if VrArgs:
........print VrArgs
........Offset=float(VrArgs[0])
# This whole if statement was added later after the introduction
# of VrArgs. If a string (or multiple strings) are placed after
# the script name, they are passed in as a list of strings. So the
# test would fail if VrArgs was empty (nothing passed) and would
# pass to the else statement. If however something was passed,
# convert it to a real number and assign it to the offset. Bonus
# points for anyone who identifies the huge bug I just noticed in
# this 3 line block.

....else:
# In other words if VrArgs is not true (is empty).

........Gui.DspMsg0('Dig offset # End for dialog') ........StatS,SnapX,SnapY,SnapZ=Gui.GetCoord('Offset')
# Same as above, display instructions and read a coordinate
# that represents how far the cursor is from the line.

........Offset=-1.0*(Line.SnapPoint (SnapX, SnapY)[3])
# Use the computed offset. The -1 is just to correct for
# how SnapPoint computes the distance.

........if StatS:
# This comes about if the user hits the end button instead
# of a 1 to cancel the digitize offset.

............PromBox=VrPromBox('Prompt title',20,1)
............PromBox.AddDouble('Enter a real number',.5,2)
............if (PromBox.Display(0) == 0):
................Offset=PromBox.GetDouble(0)
# Just a simple prombox to allow for entering the offset if
# it wasn't passed or computed in any other way.

....Num1=Line.SnapPointAdd (NewX1,NewY1,0.0)
....Num2=Line.SnapPointAdd (NewX2,NewY2,0.0)
# We are adding points to the line object that was identified
# this is ok because later we will Rec() instead of ReRec() which
# will create a new line.

....if Num1>Num2:
........tmp=Num1
........Num1=Num2
........Num2=tmp
# At one point DelPoints didn't work properly if the beginning
# point was higher than the end point (it may not still, but doesn't
# really matter if it is checked and swapped if necessary.

....Line.DelPoints (Num1, Num2, 1)
# Mode 1 in effect deletes points outside begin and end rather
# than between them (which would be mode 0)

....Line.Offset(Offset)
....Line.Rec(WsNum)
....Line.Plot()
# Take that line object, offset it by the distance entered or
# computed, record it as a new entity, plot it and there you go.
# Part of the original line has been stored as a new line parallel
# to it.
....Ws.UndoEnd(WsNum)

Reminder that as with all other scripts, you can either copy and paste what you see here (substituting your prefered indentation for the holding characters "....", or find the original at http://python4vr.googlepages.com

Life Outside Vr Wrap Up (almost)

2007-07-10T21:45:00.000-05:00

Before going back to writing functions for Vr let's wrap up a couple of things. First binary files, I have recently begun to like the idea of persistent parameters for several of my programs. I really need to create some basic generic parameter code to paste in. In the end I'll probably settle on ascii files with keywords, or at least comments. But what if you want to use binary, or what if you want to read a binary file that you know (or could guess) the structure of. An example is the old .COO coordinate files used by orientp3 in pre-Vr days. We still use it and often want to work directly with the .COO files for various things. But they are binary, here are some basics working with something similar to the parameter file we used before. This will be plain python, you can copy and paste this, download testbinary.py from my source code website, then either run it from a command line like
python testbinary.py
or open or paste it into pyedi and run it inside Vr. The only requirement is that you will need to have python installed because it uses two standard modules. By this time I am going to assume some python knowledge and ability to read the code. I am thrilled to answer any questions that come up, but I will post this code in a very plain, line at a time manner rather than using multiple methods on a single line. I'm also going to use my favorite method of accessing binary data since as is common in python there are probably dozens of ways of doing it. You could probably do this in about 8 lines but the point is to explain what is going on. I'll also assume that anyone interested in this would take the time to look up the modules listed to see how many cool things they will do... So here goes

If you were to run this script 3 consecutive times it would give 3 different responses. First that the parameter file was created but without any values read. Second it would read the default values, tell you what the values are and modify them. Third it will read the modified values print them out and tell you that it found modified values and not the defaults.

import os,struct
# We'll use os to test for the existence of the file, an struct to
# interact with the binary data.

FormatString='10sddi'
'''
The format string tells several parts of the program what we are working
with in regards to binary data. The format string listed above represents
a 10 character string, 2 double precision real numbers, and an integer.
Same as before but I added the int to show by example. Note that it is
just a string with letters representing different kinds of data.
'''

ParFileName='testbinary.par'
# The file by this name will show up in the directory the script is run in.

print 'Bytes occupied by binary data',struct.calcsize(FormatString),'\n\n'
'''
Sometimes you need to know how many bytes to read from a file in order
to get one set of data when multiple sets exist, a good example goes
back to the coordinate file mentioned earlier. In order to read and process
one point at a time you can only read the necessary bytes. the calcsize
method in struct will read a format string and tell how many bytes are
represented. You can go into a python interpreter, import struct then
evaluate some single item format strings like the following for a
float, a double, an int, and a 1 character string.
>>> struct.calcsize('f')
4
>>> struct.calcsize('d')
8
>>> struct.calcsize('i')
4
>>> struct.calcsize('s')
1
'''

if not os.path.isfile(ParFileName): # If the file doesn't exist.
...ParFile=open(ParFileName,'wb')
...# Then open it in write (create or erase) mode with a binary modifier

...BinaryData=struct.pack(FormatString,'Word',.2,.0,0)
...'''
...The pack method in the struct module uses the format string to process
...the data that comes next into the bytes which represent them in binary
...form. It is important that the amount and type of data following the
...format string match, notice I am passing in a string (less than 10
...characters allowed, 2 real numbers and an integer.
...'''

...ParFile.write(BinaryData)
...ParFile.close()
...# We have a binary file and binary data so just and write and close it.

...print 'Program run with no existing file'
...print 'Data set to defaults.'
...print 'testbinary.par should now exist.'
else:
...ParFile=open(ParFileName,'r+b')
...# If it does exist open for reading + writing with binary modifier.

...BinaryData=ParFile.read()
...'''
...This time since the file exists we are going to get the binary data
...right out of the file with a read. Since we want the whole file there
...is no reason to use calcsize to tell it how many bytes to read.
...'''

...DataList=struct.unpack(FormatString,BinaryData)
...# Going the other direction, lets use unpack to use the format string
...# to convert the binary data into a list of values.

...print 'Data from file, note it is a list\n ',DataList
...# and print the list.

...ParFile.seek(0,0)
...'''
...Now assuming that there are new values that need to be used to update
...the parameter file. The first thing we need to do is go back to the
...beginning of the file, read up on seek, but this basically moves you
...0 bytes from the beginning. If in the coordinate file example I had a
...data structure that require 24 bytes and wanted to get the 3rd value
...from the file I could to the 48th byte and read 24. This way you can
...read, write, and overwrite data in place within a file.
...'''

...print 'File position after seek ',ParFile.tell()
...# Every open file has a tell method which gives the current position.

...BinaryData=struct.pack(FormatString,'Updated',1,2,3)
...ParFile.write(BinaryData)
...# Same idea as above, just using the changed data (wherever it came from)

...if DataList[0].split('\x00')[0]=='Updated':
......print 'You have seen it all.'
......print 'Remove testbinary.par to start over'
......'''
......There may be a better way to convert this 10 character string to
......what you normally think of as a string, but it comes back padded
......with the 0 bytes and this works simply enough. Think of it this
......way 'Updated\x00\x00\x00' has 3 extra bytes, if you split on that
......character you get back ['Updated', '', '', ''] of which 'Updated'
......is the first or [0] element. Ugly but I've never really look into
......a better way.
......'''

...else:
......print 'Program run with an existing file'
......print 'Data was updated run again to see change'
......# 2nd run string doesn't equal 'Updated' so print appropriate message.

...ParFile.close()
...# Good form to explicitely close files.

I need to wrap it up for now, I'll have to save the parsing command for next time.

Life Outside Vr 4

2007-06-21T21:03:00.000-05:00

We've looked at external files with the goal of getting useful information out of them. At the same time how about saving something there. We use a program that takes symbols in a certain layer, compares their elevation to an active dtm, and if they are over a specified distance from the elevation displays the error. It is a very useful program and when it was first written had all the variables hard coded, but stored at the beginning of the file so they could be easily found and changed. With the advent of PromBox it just became too easy to allow the user to confirm and change the variables each time. You could even easily use the old hard coded values as defaults. However it seemed like a certain set of values would be used over and over again based on job specifications. The obvious solution would be to have the last values used stored between runs to be used as the new defaults. Storing values like this is easy enough, but what elements would the most elegant solution contain? I have no idea but I did come up with a couple of features I really wanted.

First lets store them in a logical location like /vr/hostdir where all the other function parameter files are stored. Truthfully it would probably be better to make a user parameter directory, but I'll be lazy for now because the next thing I wanted was a test to see if the parameter file existed already and if not, would create one with the original default values. Yes I could test for a folder and if it wasn't there create it but maybe that will come in the next version but for now I didn't really want to change the directory structure.

import os
# os is necessary to test the existence of the parameter file.

ParFileName='c:/vr/hostdir/save_params.par'
# Call it what you want, this is great code to save for later use in other
# programs that require persistence.

if not os.path.isfile(ParFileName): # Does the file exist.
open(ParFileName,'w').write('%d %.3f %.3f'%(86,.2,0.0))
# If not then create it in write mode and write an integer and 2 floating
# point numbers with 3 decimal places.

Params=open(ParFileName,'r').read().split()
# Since it either existed or was created all we need to do now is open, read
# and split the values into a list that would look like ['86','.2','0.0']

PromBox=VrPromBox('Display Sym to Dtm',20,1)
PromBox.AddInt('Layer to Check',int(Params[0]),1,1000)
PromBox.AddDouble('Display delta >',float(Params[1]),2)
PromBox.AddDouble('Text Rotation',float(Params[2]),1)
# Using the values stored in the Params list make a prombox which will allow
# the user to change the values.

if (PromBox.Display(0) == 0):
...LayerToCheck=PromBox.GetInt(0)
...DisplayDelta=PromBox.GetDouble(1)
...TextRot=(PromBox.GetDouble(2))
# Grab the new values.

open(ParFileName,'w').write('%d %.3f %.3f'%(LayerToCheck,DisplayDelta,TextRot))
# And write them out to a file.

I won't spend the time on all the uses for keeping persistent variables between sessions, but this is the basics.

This just about wraps it up for reading and writing files, except for maybe writing parameters as a binary file, just for the fun of it and maybe walking through the single line parser I posted on the forum. It isn't very flexible but offers some interesting lessons. Here's a peek.

alist=[]
for line in open('hughes.pxyzopk','r').readlines():Alist.append(line.split())

Life Outside Vr 3 (well not very far outside)

2007-06-08T23:06:00.000-05:00

Actually not at all, but the point isn't that we need to work outside Vr, it is that there is a whole world of files available using some straight python functionality. Now that we have a little file opening and reading under our belts, lets come back into Vr and bring a little of that technique with us. Let's also work on tightening up the code a little. If you are fairly new to VrPython, I think you'll really like this one. We are going to let Vr tell us the name of the file to open (in this case the current function key file) then using standard python we'll open, read, and parse the data we want out of the file, then use Vr to build a prompt box. For this example the data we want is all the function key names, and the prompt box will allow us to pick a function key name. Why? Well how about if you were going to write a parallel function using the existing inspar command but wanted to change the PARMOD= to "Function Key" and wanted to select the function key from a list then send it using the FKEY= key-in. If so, here is one way to get the function key name. It is rather long and convoluted but I'll try to make it worth what you are paying for the look.

Cfig=VrCfg()
# We'll need a Vr config object to access the name of the currently
# loaded function key file name.
FileName=Cfig.GetFkeyFileName()
# Grab the name.
FkeyFile=open(FileName,'r')
# Open the file
FileData=FkeyFile.read()
# We're going to read the file twice. This time as a string so we can count the
# instances of the key-word "KeyName" to figure out how many entries our
# prompt box will need.
NumberOfFunctionKeys=FileData.count('Fkey KeyName')
# Use the string method count to do just that.
PromBox = VrPromBox ("Function Keys", 60, 1)
# Create a PromBox object.
PromBox.AddList ("Select a Function Key",NumberOfFunctionKeys , 40, 0)
# I'll skip helpful text and just get right to the listbox of length equal to
# the number of function keys.
FkeyFile.seek(0,0)
# Rewind the file to read it again.
FileData=FkeyFile.readlines()
# This time read it as a list, each element of which is a line from the file.
for FileLine in FileData:
# For each line in the data list.
..if FileLine.count('Fkey KeyName') != 0:
# Test to see if it is a line containing the function key name.
....FkeyName=FileLine.split()[2]
# If so split the line data into the three words
# 'Fkey','KeyName','ActualName' which is in itself a list, the third element
# of which ( [2] ) is the actual name of the function key.
....PromBox.AddListItem(FkeyName)
# Add that to the list of items to be displayed.
FkeyFile.close()
# Could have closed it after the readlines() but just go ahead and do it now.
if (PromBox.Display(0) == 0):
..FunctionKey=PromBox.GetList (0)
# Standard prompt box usage to grab a list item
print FunctionKey
# and print it out (or use it in an interesting way)

Now as far as tightening it up. I could have read the file only once and built a for loop to count the instances of the KeyName key-word, but I'm going to go in a totally different direction. I'm still going to read the file twice, as a matter of fact I'm going to open it twice. The goal of this exercise is to get as few lines of code as I can. I'm not going to profess that this is the tightest and most efficient. It just has a lot less lines of code and is intended to make you think. Look at it first, then read the explanation.

PromBox = VrPromBox ("Function Keys", 60, 1)
PromBox.AddList ("Select a Function Key", open(VrCfg().GetFkeyFileName (),'r').read().count('Fkey KeyName'), 40, 0)
for FileLine in open(VrCfg().GetFkeyFileName (),'r').readlines():
..if FileLine.count('Fkey KeyName'):PromBox.AddListItem(FileLine.split()[2])
if (PromBox.Display(0) == 0):print PromBox.GetList (0)

Line 1: We have to create a prompt box object because I can't find any way around it and we'll need to use methods of this specific object in the next line.

Line 2: Let's take this a step at a time.
A) Add to the list using the formula AddList (Prompt, NumItems, Height, DefaultItem) Prompt is set to "Select a Function Key", NumItems is the tricky part, Height is 40 and DefaultItem is 0.
B) Look at the NumItems formula and read it as follows
Open a file using the string returned by a VrCfig() object method GetFkeyFileName in read mode ( 'r' ) which open file object you should read() the data, of which data you should count() the number of occurrences of 'Fkey KeyName'. Notice that when all this is said and done it just give a number which represents the number of function key names and therefore the number of function keys

Now that we have a prompt box which contains a list set to the length equal to the number of function key names, let's populate the list with those names.

Line 3: For each element in a list, the list comes from opening the same file again, in read mode again, but this time instead of read() to get one solid string, we use a method that will return a list which is exactly what the for loop is working on. We are looping on a list that was created and populated just for the loop, each element of which is a line from that file.

Line 4: FileLine represents the line of data out of the file which is being examined as we loop over the entire list of lines. count() tells how many occurrences of a work exist in the string 0 means none which in terms of an if means false so any other number that comes back means true (the string exists, therefore it is a function key name). if it is true we want to add the actual name to the list. The actual name as we saw above means splitting the string, which creates a list, from which we want element [2]. So add to the list the third word which is the result of splitting the string because it does (true) contain the phrase 'Fkey KeyName'. I didn't add another line and indent it because there is only one statement to execute if true which allows you to just put it after the colon and be done with it.

Line 5: Same idea, standard prombox syntax, but since there is only one action, just put it on the same line. Ugly code but remember my only goal was to reduce the line count. And why put the string in a variable just to print it on the next line, print it as it returns from GetList()

And I haven't even taken the time to explain the forum post regarding reading and parsing aerosys .pxyzopk files, a great example of the kind of data we mappers work with all the time. Maybe next time.

Life Outside Vr 2

2007-05-21T09:48:00.000-05:00

Ok I have a few minutes so let's look at actually reading some data out of an open file. We'll stick with ascii files for now. There are so many fun reasons to work with files outside Vr that it would take too long to enumerate all of them but a few of my favorites include.

Reading info out of an ImageUtil project and creating all the Vr2Ori project and all models with 1 click.
Converting all Vr2Ori and VrAt files to or from their corresponding equivalents in orientp3 (yes we still use it and get along fine) so a setup in the analytical equals a setup in softcopy or vice versa.
Reading a PATB and plotting it graphically in VrOne for visual analysis and blunder checking.
Reading and plotting AT results including photos, layout data, computed extents and photo scale based on image centers and control averages.

You get the idea, there are just so many files out there that can be of easy use with a click or two. Sometimes there is already a way to do the same things, but a custom program allows you to set things up exactly the way you want without any further intervention. As in the last post we'll be working with vr.cfg in read only mode because it is a file that exists on everyones system (if you are working in Vr, which I assume) and has the same basic patterns. Again I will suggest you work in some kind of python IDE, I suggest pythonwin but you could even work from the python command interpreter if you want.

Let's start by creating a python file object like we did last time, it will be called f (for file).
f=open('/vr/hostdir/vr.cfg','r') # 'r' means read mode.
now if I
print f
there should be some obscure text describing the object. Hopefully there was some time to look over the file object docs to study up on the simple methods, let's look at a few.
Read one line out of the open file
>>> f.readline()
'# VR Configuration File\n'
I should note here that once it reads the line, the address in the file that python is sitting at is the beginning of the next line so if you do it again
>>> f.readline()
'# FileName : c:\\vr\\hostdir\\vr.cfg\n'
if for some reason it is necessary to go back to the beginning of the file we need to "seek" the new position. seek takes two arguments "offset" (how much to jump from the position passed in) and "whence" (where to start the offset). "Whence" defaults to the beginning of the file, so if you want to go the the beginning you can say "see" with an offset of 0 (don't move at all from the position passed in) and a whence of 0 (or if you pass nothing for whence this is the default) so
f.seek(0,0) # 0 offset, 0 whence
f.seek(0) # 0 offset, default whence which is 0
will both take python to the beginning of the file, so do that then readline() again and you should see the first line again. Let's read that first line and store it as a string we'll call "s"
>>> s=f.readline()
>>> print s
# VR Configuration File
It would of course be possible to do this with each line of the file, though there are better methods to be discussed later, but lets look a what we could do with that string now that we have it.
I can split it based on white spaces (the default for split) which returns a list of the words in the string.
>>> s.split()
['#', 'VR', 'Configuration', 'File']
For that matter we could split it based on any character like commas, or in this case the "i"
>>> s.split('i')
['# VR Conf', 'gurat', 'on F', 'le\n']
Note that splitting on white spaces takes off the newline character but splitting on a printable character doesn't. Of course there are plenty of ways to take the newline off, but just take note for now. How about if we needed to test for a sub string inside the string, well let's count occurrences.
>>> s.count('i')
3
>>> s.count('ig')
1
>>> s.count('z')
0
So a test would look something like
>>> if s.count('ig') : print 'yes'
...
yes
I didn't say if s.count equals something or is greater than something because I just wanted to know if it was non zero and anything non zero is true for the if test.

There is no sense typing out all the things you can do with strings because they are documented in the python docs, it is worth noting that there used to be a string module, but now each of these methods is a built-in which is why there was never an import statement above.

Let's go back to the split step and put the resulting list in a variable called "l", then we can loop over the list and do whatever we want, in this example just print each item.
>>> l=s.split()
>>> l
['#', 'VR', 'Configuration', 'File']
>>> for item in l:
... print item
...
#
VR
Configuration
File
or grab individual elements of the list.
>>> l[3]
'File'
or test to see if the list contains certain values.
>>> l.count('File')
1
>>> l.count('Nothing')
0
Like strings I'll leave the explanation of lists and their methods to the professionals, in this case the python tutorials.
But I'll leave with a couple of thoughts:
First, check out readlines() it will come in handy and will probably bear heavily in the next post.
Second, one of the real beauties of python is it's ability to get a lot done with a little code, this can be accomplished by taking whatever data a method returns and acting on it with the appropriate method. Consider the following lines typed into the interpreter.

open() is going to return a file object with all it's accompanying methods.
>>> open('/vr/hostdir/vr.cfg','r')
obscure text describing an open file object

let's just tack the readline() onto the end and let it return the first line which is a string.
>>> open('/vr/hostdir/vr.cfg','r').readline()
'# VR Configuration File\n'

It it is a string we can split it to get a list of words that were included.
>>> open('/vr/hostdir/vr.cfg','r').readline().split()
['#', 'VR', 'Configuration', 'File']

Of course the list is made up of elements that can be addressed lets get the second element whose index is 1.
>>> open('/vr/hostdir/vr.cfg','r').readline().split()[1]
'VR'

Which is a string and can be forced to lower case using the lower() method.
>>> open('/vr/hostdir/vr.cfg','r').readline().split()[1].lower()
'vr'

Is this stuff cool or what.

Life outside Vr

2007-05-10T18:04:00.000-05:00

I have had several folks ask about opening reading and parsing external files. There are so many applications that I don't even know where to begin. Whether plain ascii text files, or binary, python is loaded with tools for doing what you want or need. I think I'll just start rambling and see where we head. One thing that you will notice immediately is that there can be literally dozens of ways of accomplishing the same task. I'm not going to pretend that what I am putting forward is the best or most efficient, I'll just mention some tools that come in handy quite often. For today lets just open a file and grab some data from it. Let's pick a file that everyone should have, that being your Vr configuration file \vr\hostdir\vr.cfg. Don't worry, for now we'll just open it in read only mode. In your favorite python editor or pyedi within VrOne type and run the following.

f=open('\vr\hostdir\vr.cfg','r')

Ok, I'll admit that was a trick, it shouldn't have worked, even though everything about the command is totally correct, except that is for the backslashes "\". But wait you say, we are working in windows, and the backslash is what is always used to specify path hierarchy, and you would be correct. The problem is that the backslash is a special character in python (and several other languages, not to mention unix). Python uses a forward slash to separate path elements, or to use backslashes you have to tell python you are sending it a "raw" string and that it should not treat the backslashes as escape characters. I don't start here to be bothersome, but it is important to understand that python expects certain things and may send back something you aren't expecting if you aren't careful. Note the paste of a session where I open the file using 3 valid commands, look at what comes back, and realize that this is outside VrOne in the PythonWin editor.

First I open it with forward slashes because I grew up on unix, the forward slash is always in the same place no matter what keyboard you have, it is what python prefers, and I just like it better. I'll use "f" as the open file object and will open it, display it, and close it. The 'r' means to open it in read-only mode, we'll talk about modes later but I digress.

>>> f=open('/vr/hostdir/vr.cfg','r')
>>> f
Text describing file object which blogger deletes for some reason.
>>> f.close()

Next we'll use backslashes, but they have to be protected by another character so they aren't evaluated as an escape sequence, by coincidence the character that does this is a backslash so each occurence must be entered as
>>> f=open('\\vr\\hostdir\\vr.cfg','r')
>>> f
Text describing file object which blogger deletes for some reason.
>>> f.close()

Next we'll use the backslashes but we'll tell python that the name string is a raw string and that the backslashes shouldn't be evaluated as anything else. Just put an r in front of it and we're good to go.
>>> f=open(r'\vr\hostdir\vr.cfg','r')
>>> f
Text describing file object which blogger deletes for some reason.
>>> f.close()

It is worth noting that if you grab a filename inside Vr using either of the following, it returns forward slashes.
print PyVrGui().OpenFileNameDialog('title','c:/vr/hostdir','*.cfg')
C:/vr/hostdir/vr.cfg
print PyVrGui().OpenFileNameDialog('title','c:\\vr\\hostdir','*.cfg')
C:/vr/hostdir/vr.cfg

That will do for now. Yeah it's pretty slim, but I need to go and we'll actually read something next time. For now though it wouldn't hurt to get familiar with some of the python file methods, from the python docs. You can also get a little more information on the open function from the built-in functions docs (just scroll down to open()), this will come in handy when we move to appending, writing, and binary files.

Still breathing

2007-05-07T09:59:00.000-05:00

Just a quick apology that with one graduating college, one high school, and another 2 with year end activities to take in, I just haven't had time to get into anything. I even know where I would like to head but will have to put it on hold for a few weeks. Check back.

Tag team programming

2007-04-20T14:27:00.000-05:00

Not long ago I was corresponding with W. Chesson Godfrey aka Wild_Bill from the forum and he shared a little script with me. As so often happens when two people look at an issue from two different perspectives they will each solve the puzzle as it best suits their office culture. This is a little something I hadn't thought about before, which I changed to use some functions he wasn't using and shazam (is that a word) we have WsMan.py or workspace manager. Another reason why discussion is almost always a good thing. This stuff is just too cool.

PromBox=VrPromBox('Set Active Ws',60,1)
# The whole app revolves around a single convenient Prompt box, so create an object.
PromBox.AddMessage ("Don't change workspaces\n in the middle of a function")
# A little helpful text.
PromBox.AddCombo ('Workspaces',PyVrWs().GetWsCount(),0,0)
'''
We'll use a ComboBox as the user interface, so create it with the
number of items set to the number of workspaces. In this case I'm not
implicitly creating a workspace object. I just use the class to call
a method. Someday I'll test to see if this method of creating a
temporary object causes memory problems in things like large loops,
but for now I'm just illustrating that you don't necessarily need to
do the Ws=PyVrWs() thing.
'''
for WsNum in range(PyVrWs().GetWsCount()):
....PromBox.AddComboItem (PyVrWs().GetFileName (WsNum))
# For every workspace, get it's name and add it to the combo box.
if (PromBox.Display(0) == 0):
....PyVrWs().SetAws(PromBox.GetCombo(0))
# If the user didn't hit cancel, then set the active workspace
# to match the one selected.

Get involved in the forums, there is a wealth of experience to be shared.

Utility programs 3

2007-04-16T04:38:00.000-05:00

Ok, time flies and all, but we better get some actual working code in this thing. In post 1 all we did was create a usage string and test argv to see if anything had been passed in (in this case we don't want anything). In the second we used glob to build a list of files matching a certain extension in the directory we're working in. Eventually we could us a windows file select dialog but for now this will be a simple command line utility. Let's get right to the pertinent section then put it all together in the end. Using th same indentation as where we left off, lets replace

........print os.path.splitext(File)

which was just used to show that something was working and to illustrate os.path functions with

# Step through the list of files processing each
....for File in Filelist:
# Each file will need to be opened
........OppFile=open(File,'r')
# readlines() reads every line in a file, returns a list in which each member
# of the list is a line in the file, including the end of line character.
........FileData=OppFile.readlines()
# Step through the list of lines in the open file
........for Line in FileData:
# This isn't real tricky or elegant, but it turns out that the coordinate
# positions stored in the .opp file are on lines which have an "l" as the
# second character, so let's just determine first of all if the data line
# is a coordinate
............if Line[1]=='l':
# Then if it is, the first character determines which coordinate it is.
# If it's an X, Y, or Z we'll use the split(function) to break the line
# into a list of strings, which contains the number as the second
# element, then use float() to convert it to a real number, and store it
# in the appropriate variable.
................if Line[0]=='X':
....................X=float(Line.split()[1])
................elif Line[0]=='Y':
....................Y=float(Line.split()[1])
................elif Line[0]=='Z':
....................Z=float(Line.split()[1])
# Once we have parsed each line in the file to pull out the coordinates
# lets use some formatted printing to output the file name and values.
# Remember that "File" contains the name of the file with the extension
# so the split using the dot will give a list ['filename','extension']
# so the base name is element 1 or [0]
# Close the file and your on your way.
........print '%s %.3lf %.3lf %.3lf'%(File.split('.')[0],X,Y,Z)
........OppFile.close()

so in the end after removing the modules that were only temporary, the final program looks like

import sys,glob

def usage():
....'''
....Explanation text to print if anything is entered as an argument.
....'''
....print '\nUsage: python opp2txt.py\nThere are no arguments, it will just look in the current directory\n for files with a .opp extension, strip the coordinates out of them\n and output them to the screen\n\nListings can be redirected into a file.\n eg: python opp2txt.py > photos.txt'
....sys.exit(1)

if len(sys.argv)==1:
....Filelist=glob.glob('*.opp')
....if Filelist==[]:
........print "There don't appear to be any .opp files in this directory"
........sys.exit(2)
....for File in Filelist:
........OppFile=open(File,'r')
........FileData=OppFile.readlines()
........for Line in FileData:
............if Line[1]=='l':
................if Line[0]=='X':
....................X=float(Line.split()[1])
................elif Line[0]=='Y':
....................Y=float(Line.split()[1])
................elif Line[0]=='Z':
....................Z=float(Line.split()[1])
........print '%s %.3lf %.3lf %.3lf'%(File.split('.')[0],X,Y,Z)
........OppFile.close()
else: usage()

Now this just prints to the screen and would have to be redirected to a text file. For the fun of it the first modification once we know it is running would be to send it directly to a file. As always, final working code is found on my personal VrPython website.

Utility programs 2

2007-04-07T07:10:00.000-05:00

Rather than retyping the code from the previous post, I'm just going back to the line with argv and proceed from there with some actual working code. This time I want to focus on getting the filenames that will be processed. Remember the test of argv was just to determine if any arguments were passed. Since this program doesn't take any, having something else appear on the command line indicates a lack of understanding so we printed some usage instructions. Now let's assume the user knows that if he types "python opp2txt.py" he will get every opp file in the directory processed. But how to build a list of file names? Today we'll just build the list and print the filenames to show that it worked. The magic we want is contained in the glob module, no I don't know why it is named that, but isn't that just about the coolest name around? Here is the code that could be inserted into opp2txt.py to grab filenames.

if len(sys.argv)==1:
....Filelist=glob.glob('*.opp')
....if Filelist==[]:
........print "There don't appear to be any .opp files in this directory"
........sys.exit(2)
....for File in Filelist:
........print os.path.splitext(File)
else: usage()

First let's look at glob. The module itself is fairly simple and can be found in the python module docs. The short story is that you can return filenames matching a pattern in a specified directory into a list of strings. Really the best way to illustrate is to try it. In your favorite python editor do the following.

import glob
glob.glob(r'\vr\hostdir\*.par')

This should return a list which contains the names of every .par file in that directory. Something like...
'\\vr\\hostdir\\drivefile.par', '\\vr\\hostdir\\editline.par',
The lower case r before the path name just tells python to treat the string that follows as a raw string and not to see the backslashes as special characters. You could also put in forward slashes without the 'r' since that is a valid path separator in python but the return list comes back as an odd mix of forward and backward slashes.

We are storing the returned list in a variable called Filelist. If there are no .opp files in the directory the list will be empty in which case we print a message to that effect and exit, I just picked a random exit code of 2 to indicate no files found.

Next the for loop will step through the list and process each name string in the list. The variable which represents the name string will be "File".

Meaningful processing will come next time, but for now we could just use the code "print File" to display each filename but let's take this opportunity to explore the extremely useful os.path functions. These are most helpful in separating components of full filenames into paths, extensions, base filenames, etc. In the program which will be run in a directory that includes the .opp files and will not contain a path component the list would look something like...
['1.opp', '2.opp']
and the splitext() will just return a name and an extension similar to...
('1', '.opp')
('2', '.opp')
which could be accessed individually using indexes
>>> print ('2', '.opp')[0]
2
>>> print ('2', '.opp')[1]
.opp
>>>
However to really have some fun lets go back to the previous example in the editor and try some examples with the name list returned from the vr hostdir directory. Here are some truncated examples of what would be returned. Take time to play with the os.path functions, there is some real usefulness there.

>>> for name in glob.glob(r'\vr\hostdir\*.par'):
... print os.path.basename(name)
...
drivefile.par
editline.par

or if we run it through splitext() after it has been stripped to basename.

>>> for name in glob.glob(r'\vr\hostdir\*.par'):
... print os.path.splitext(os.path.basename(name))
...
('drivefile', '.par')
('editline', '.par')

or how about just running splitext to get the filename so that you can create another file with the same name, but with a different extension.

>>> for name in glob.glob(r'\vr\hostdir\*.par'):
... print os.path.splitext(name)
...
('\\vr\\hostdir\\drivefile', '.par')
('\\vr\\hostdir\\editline', '.par')

or what about if you want to get the path name so you can create a file in the same directory.

>>> for name in glob.glob(r'\vr\hostdir\*.par'):
... print os.path.split(name)
...
('\\vr\\hostdir', 'drivefile.par')
('\\vr\\hostdir', 'editline.par')

or just test whether or not the file exists, of course all these do because we're just passing in existing file names, but you get the idea.

>>> for name in glob.glob(r'\vr\hostdir\*.par'):
... print os.path.exists(name)
...
True
True

Cool stuff, and we haven't even done anything useful yet, hopefully next time.

The forums are back!

2007-04-06T07:39:00.000-05:00

I'll post more on opp2txt more this weekend but I just had to mention that the Vr Forums are back. As I understand it they aren't technical support forums so much as a gathering place for users to share information. In that sense if used properly they could be an invaluable place to discuss problems, questions, tips, tricks and other useful information. Check them out at http://www.cardinalsystems.net/forum/

Utility programs 1

2007-04-03T12:26:00.000-05:00

Ok so I said I was going to talk about function key parsing and python dictionaries, and I will... eventually. I got off on a small tangent though and decided that it would be beneficial to start out talking about external utility programs first. There are probably many uses for a nice organized function key data set, both inside Vr and out. But lets start small. I love little command line utilities that take the place of actually working, as a matter of fact if I have a motto it would be "It beats working" and the more times I have reason to say that on any give day the better. Here is an example...

When I am working with ortho's there are times that I would like to have the photo centers plotted in a file. Because almost everything in Vr is stored in easy to read, easy to interpret text files it is a piece of cake to go into the opp files and pull out the xyz coordinates in any text editor. But do that on 100 separate files and you are bordering on work. What if you could just run a simple little command line utility that would give you a space separated listing of the photo name and it's coordinates. That my friend "beats working". Let's think through this program a few lines at a time, when it's all said and done I'll post the final code on the repository web site.

First for the preliminaries

# Lets start out with a docstring to explain what the program is for.
'''
Extracts photo center coordinates from all .opp files in a directory
and sends the output to the screen, which can then be redirected into
a text file.
'''
# For now just trust me that these are the modules we'll need.
import os,sys,string,glob
# It's always a good idea to put in a usage function. In this case since
# (like it says) there won't be any arguments, will force the usage string
# to print if the user enters any argument at all.
def usage():
....'''
....Explanation text to print if anything is entered as an argument.
....'''
....print '\nUsage: python opp2txt.py'
....print 'There are no arguments, it will just look in the current '
....print 'directory for files with a .opp extension, strip the '
....print 'coordinates out of them and output them to the screen'
....print '\n\nListings can be redirected into a file.'
....print 'eg: python opp2txt.py > photos.txt'
....sys.exit(1)
# This is the main part of the program. First we'll make sure no
# arguments were entered. sys.argv is the command itself the program
# name is always the first argument, if there is only 1 thing in the
# list then no arguments besides the program name were passed.
if len(sys.argv)==1:
....print 'no code yet run\npython opp2txt.py -h\nfor help'
else: usage()

Ok that's it for now. Copy the above to a python file called opp2txt.py , replace the indent holders (....) with your normal indentation and run it with an argument and it will describe where we are headed. You need python installed and in the path. Type "python opp2txt.py -h" and the usage should print.

If you want to get a better idea what argv does just create a python script that contains nothing except
import sys
print sys.argv
Then run the script with different (or no) arguments.
More to come...

Solid gold

2007-03-30T12:39:00.000-05:00

Ok I haven't posted in too long and this one is going to be really short, but I have some really fun plans along the lines of a function key parser, editor, etc. that will really push into the python dictionary data type.

For now though let me pass along huge kudos to the team at Cardinal. I often have thoughts of the guys slaving away in the salt mines at the Vr Development lab. Poorly used and un-appreciated for the efforts that spring forth. However in the latest patch versions (usual disclaimers about beta software, or anything that isn't in official full release, blah..blah..) there are a couple of nuggets of pure gold. One is attaching in fly-line, granted this doesn't have anything to do with python, but along with things like all the different snap options, overloading (I better stop before I get carried away) attaching a fly-line is one of those things that will make me pause and think "wow, I love this stuff". The python related gold nugget is Ws.IdEnt() which allows the user to just start a generic ID routine then select anything on the screen, or cycle through entity types. This is the same ID that is used for fasdel and others like it. Check it out on the python help pages, it is absolutely too cool.

I'll also toss in a little utility that I use to save the current layer display status. Disclaimer here is that it only works with 3.2 and above because before that PyVrLayer had it's own module. It could be modified to work like that, but this version doesn't.

Layer = VrLayer ()
Gui=PyVrGui()
# Initialize Vr objects to be used.
parfile=open('c:/vr/hostdir/save_lay_stat.par','w')
# Open a parameter file to save the layer status in. 'w' is write mode.
for laynum in range(1000):
..parfile.write("%d %d\n"%(laynum,Layer.Stat(laynum)))
Gui.DspMsg0('Layer state saved')
# I'm only going to save the status of the first 1000 layers, I rarely use any others.
# Then write the Stat() or current status along with the layer number.
parfile.close()
# Always close files when done. Python is smart this way, but it's good practice.

A touch of class

2007-03-02T08:38:00.000-05:00

You can do an amazing amount of good with VrPython without knowing anything about Object Oriented Programming (OOP). For that matter most, or at least many things you can do without even knowing much about Python. In my opinion though, knowing more is always better than knowing less. Let's talk a little about how I understand OOP working out in Vr. To begin with there is a very good explanation of the basic concepts on Wikipedia. I could make up my own example of the biggies like class, object, inheritance but they do such a good job there that I'll just trust anyone who needs a basic understanding to read it (3-5 minutes tops).
Let's look at a line. In VrPython there is a class called PyVrLine. Any object which is created from that class has many attributes, characteristics, data (whatever you want to call it) which describes it's state. Examples of these attributes (the word I'll stick with) are it's layer, graphic pointer, width, coordinate list and so on. A line also has many methods, or functions it can perform based primarily on it's current state. When ever I create an individual object or instance of that class, I have access to all the attributes and methods that go with it. In Vr the individual object is created with the command
Line=PyVrLine()
I have often wondered if I am confusing things by using the word "Line" as the name of the particular object. Sure it is descriptive and relevant, but for example purposes it needs to be clear that I could use any name for the object being created which is of the class PyVrLine. It is just an identifier of the unique entity I'll be using just like Dennis is just a name used to identify this particular object of the Human class.
In any case, whatever we call a particular instance, once we have a PyVrLine(), the fun can begin. On of the most useful functions when starting off is Id(). Once there is a PyVrLine object, Id() will use the function built into it to bring up a familiar set of identification menu keys and wait for the user to click button #1. If the click meets all the criteria to find a line Id() will not only return the line number of the line it found, but will populate the PyVrLine object with all the attributes of the identified entity. It does the exact same thing as Load() but allows for visual identification in the current workspace. Once the PyVrLine object is loaded (or I suppose created from scratch with default values) the whole host of methods that can get, set, or compute information based on the current state become available.
The key is that a Vr object can't just be looked at even as a complex collection of data, but also as the family of functions that allow user interaction with it. This frees the developers to grant access to the power of the internal magic in a secure manner, and the user from having to understand what is going on (or having to re-invent the wheel for typical data interaction).
Ok I'm rambling and really need to bring this to a close. Besides the fact that OOP is really cool, and it helps to have a simple understanding of how it works out in Vr, what is the point? Is there any reason that a person might want to learn to use classes in everyday programming? I very rarely do, and most of the true object oriented modules I've written were done because I wanted to give it a try, but here is an example. I have a module which contains an angle class. An object created from this class of course stores the value of the angle it represents, but it also contains methods that allow it to represent itself in radians, degree-minutes-seconds, decimal degrees, bearings with quadrant, any of the above in varying text formats along with an overloaded repr(). Along with this there are methods that allow for conversion between the varying systems. All these things are easy enough to do on the fly, but a consistent interface and descriptive names make programs that use the class easier to read, and playing with basics like this makes understanding modules written by really intelligent programmers a bit easier to follow.

I can already do that

2007-02-20T08:58:00.000-05:00

Why are there 4672 different word processors or hundreds of CAD programs available (I made the numbers up)? Because somewhere, sometime, a programmer was sitting at his keyboard whacking away on something he felt was truly important and when someone said "I can already do that", the first words out of the programmers mouth were "yeah, but....". I am today formally proposing that this be adopted as the official motto of petty programmers everywhere. For example there are at least two perfectly good ways to remove the arc codes from a Vr line entity. If you want to clear entire layers of the pesky point flags, delarc is the ticket. For a single line or two edilin has the ever popular B6,B6 combo that will do the same thing for any line you latch on to. "Yeah, but" what if I want clear 5 individual lines in a point and click method where each line identified is cleared of arc codes (or any other flags which is part of the moral of this post). How about clear_arc.py?

As a whole it looks like.

Ws=PyVrWs()
Line=PyVrLine()
WsNum=Ws.Aws()

while Line.Id() != -1:
..Ws.UndoBegin(WsNum,"clear_arc")
..for PointNum in range (0, Line.GetNumXyz()):
....p, a, c, f, m = Line.GetPointFlags (PointNum)
....Line.SetPointFlags (PointNum,p,0,c,f,m)
..Line.ReRec ()
..Line.SetWidth(2)
..Line.Plot()
..Ws.UndoEnd(WsNum)

Taken apart.

Ws=PyVrWs()
Line=PyVrLine()
WsNum=Ws.Aws()
Initialize what will be needed.

while Line.Id() != -1:
Been a while since we've used the Id() function, remember that it returns an open object, ready to interact with.

..Ws.UndoBegin(WsNum,"clear_arc")
This time the undo points are set inside the Id() loop so if the wrong one is identified the user could just exit and undo the last modification while anything else would remain cleared.

..for PointNum in range (0, Line.GetNumXyz()):
For every point on the identified line.

....p, a, c, f, m = Line.GetPointFlags (PointNum)
Get the existing point flags.

....Line.SetPointFlags (PointNum,p,0,c,f,m)
Set them all back as they were except for the arc flag which will be set to 0.

..Line.ReRec ()
Re-record the line that is loaded.

..Line.SetWidth(2)
..Line.Plot()
Change the graphics as a verification and plot it (after the ReRec so graphic changes aren't stored).

..Ws.UndoEnd(WsNum)
Set the undo endpoint for each line identified.

Note that point flags are documented in the VrPython documentation as follows.

p, a, c, f, m Flags

p-Pen code (0=None 1=Up 2=Continue 4=End)
a-Arc flag (0=None 1=Beginning, end or PRC 2=Mid point 3=Point on arc)
c-Code (0-255)
f-Bit encoded flag (0-255)
m-Mosaic width (0-255)

If a parameter is passed as –1 then the original number is not changed
Example Line.SetPointFlags (PntNum, PenCode, ArcFlag, Code, BitFlags, MosaicWidth)

The bit encoded flag isn't used much that I know of and can be a handy way to mark a point for further consideration, Always check with someone at Cardinal Systems before using this flag because if it is implemented for something then there could be conflicts between a python program and Vr functions that use the same bit. A good example of this is to run batnod, id a line that was noded, move to a node point, and look at the f display in the menukeys dialog.

Computing without errors

2007-02-12T13:03:00.000-05:00

Wouldn't it be a lot more fun to write code if you could guarantee that those pesky end users would never enter the wrong type of data? Not to mention, shouldn't it be their responsibility to know the bounds of whatever is entered or passed to the program. After all isn't it enough that some helpful soul is writing code to make every one's life easier, why should I care if the "File does not exist". Well we all know that errors happen (sometimes even the program isn't perfect). One helpful tool when unexpected problems arise is the try: - except: block. In simple terms anything that falls within a try: block and causes a potentially fatal error, should cause execution to jump directly to the except: block.

#try-except.py
print '\nTesting try:'
try:
..print "divide 1 by 3 and it's ok",1.0/3.0
except:
..print 'it worked so this never prints'
try:
..print "This prints until it does the division of 1 by 'a' then ",1.0/'a'
except:
..print '\nThere is an error that would normally end the program\nbut instead jumps to the exception'
print '\n'

Should print.
divide 1 by 3 and it's ok 0.333333333333
This prints until it does the division of 1 by 'a' then
There is an error that would normally end the program
but instead jumps to the exception

try-except.py
print '\nTesting try:'
try:
..print "divide 1 by 3 and it's ok",1.0/3.0
Anything that should happen as part of normal execution goes inside the "try" block, probably including a proper exit code if you are a good programmer and this is a non-Vr program.
except:
..print 'it worked so this never prints'
Anything that should be done if there is any kind of error encountered in the try block should go in the "except" block. This is a good place to inform the user that something went wrong. In this example this line never gets printed because there is no error in the code.
try:
..print "This prints until it does the division of 1 by 'a' then ",1.0/'a'
Here the error is that there is a division by a string, notice that if it had worked there would have been some characters printed directly after the word "then", since the error is in the division the error comes at this point and execution would normally print out a bunch of cryptic python like error statements.
except:
..print '\nThere is an error that would normally end the program\nbut instead jumps to the exception'
print '\n'
However since we "trapped the exception", execution continues with the first statement in the except block.

I don't use try for every line of code I write, mostly because I'm lazy and they are for personal or in-house usage. The more likely an important program is to leave the building, the more likely I am to worry about exceptions. Within VrPython I tend to use them where there is a reasonable expectation that the same problem could come up on a regular basis.

News flash for the slow to catch on

2007-02-09T14:10:00.000-05:00

While posting on The Scripts Developer's Network python forum, someone pointed out to me that string.atoi (and atof) have been deprecated ( I hope I'm never deprecated, it sounds painful) and the preferred methods are the built-in functions int() and float(). I'm not sure when it happened because I apparently didn't get the memo, but especially if you have moved up to Vr 3.2 and Python 2.5, it is probably something to take note of.

It keeps growing, and growing....

2007-02-07T06:43:00.000-05:00

Some programs seem a little like Frankenstein's monster. You know, you start out to re-animate a little dead flesh in your spare time, and the next thing you know the peasants are in a uproar. Well, not quite, but it really seems like some of the smallest projects eventually take on a life of their own. (Note that in many places, this would be considered humor, poor humor, but humor. Apologies if it seems offensive where you are)

Here is an example that also shows some interesting concepts. History: One day I was doing something and thought "It sure would be nice if I could throw a north arrow on the screen any time I like to remind me which way north is". Just a simple little thought, easily enough accomplished with a couple of lines of python, nothing stored in the file, just displayed and then erased at the next refresh.. Later I thought, "Sometimes when I'm adjusting a display it would be nice to know where the exact center of the display and it's edges are". Then because we still do the majority of work on analytical instruments, I have always missed the ability in Vr's predecessor to show me where the instrument was in relation to the screen. Well as long as I'm showing North, and the centers of all the edges, why not draw a line from the screen center to the current cursor (instrument) location that would indicate where the instrument is.

See how it goes, next thing you know there are lines and symbols all over the screen, but each one helpful in it's own way. I call this ugly duck screen_center.py (for reasons which now escape me).

def Rad2DecDeg(Radians=0):
..return Radians*(180.00/3.1415926535897931)

Gui = PyVrGui()
Gr=PyVrGr()
Line=PyVrLine()
Sym=PyVrSym()

LineLayer=105
LineGraphic=1
NorthGraphic=58
TickGraphic=41
SymLayer=102
Radius=.75

Gui.DspMsg0('Rotation = %.2f'%(Rad2DecDeg(Gr.GetWinRot()[2])))
Sym.SetCoord(Gr.GetWinOrg()[0],Gr.GetWinOrg()[1],Gr.GetWinOrg()[2])
Sym.SetLayer(SymLayer)
Sym.SetGpoint(NorthGraphic)
Sym.SetRad(Gr.GetWinScale()*Radius)
Sym.SetRot(0)
Sym.Plot()
x,y,z,key = Gr.GetCursor ()
Line.SetLayer (LineLayer)
Line.SetGpoint (LineGraphic)
Line.AddPoint(Gr.GetWinOrg()[0],Gr.GetWinOrg()[1],Gr.GetWinOrg()[2])
Line.AddPoint (x, y, z)
Line.Plot()
Sym.SetGpoint(TickGraphic)
Sym.SetRad(Gr.GetWinScale()*.25)
for corner in range(4):
..x1,y1,z1=Gr.GetWinCorner (corner,0)
..Sym.SetCoord(x1,y1,z1)
..Sym.Plot()
..if corner==3:x2,y2,z2=Gr.GetWinCorner (0,0)
..else:x2,y2,z2=Gr.GetWinCorner (corner+1,0)
..Sym.SetCoord(((x1+x2)/2.0),((y1+y2)/2.0),z1)
..Sym.Plot()

And away we go...

def Rad2DecDeg(Radians=0):
..return Radians*(180.00/3.1415926535897931)
We'll be grabbing some parameters later that will be returned in radians. In the US we (or at least I) visualize decimal degrees more easily. The rotation is just going to be displayed in a message area, so we might as well make it readable. In the actual program I import math, and use math.pi instead of the 3.14 number but I'm trying harder to make these posts independent of python.

Gui = PyVrGui()
Gr=PyVrGr()
Line=PyVrLine()
Sym=PyVrSym()
All this is typical, except this may be the first time that PyVrGr has been mentioned. This is a class that allows us to interact with the graphics window. In this case we'll mostly be getting information from it.

LineLayer=105
LineGraphic=1
NorthGraphic=58
TickGraphic=41
SymLayer=102
Radius=.75
Once it is all said and done there will be a north arrow in the exact center of the display, ticks (simple cross) in the center of the edges, and a line from the screen center to the current cursor position. Radius is in inches and will be set based on the screen scale later. All the symbols will go in the same layer, though there will be a different graphic for the side ticks, and the center north arrow.

Gui.DspMsg0('Rotation = %.2f'%(Rad2DecDeg(Gr.GetWinRot()[2])))
If we end it here, there will just be a message in the Vr message area that give us the screen rotation, helpful in it's own right, but let's add a graphic display.

Sym.SetCoord(Gr.GetWinOrg()[0],Gr.GetWinOrg()[1],Gr.GetWinOrg()[2])
Here is a python concept, GetWinOrg returns a 3 number list with x,y, and z as the values. In the above line SetCoord will set the symbols x,y,z location values with the list values returned by GetWinOrg. If the list returned would be (1,2,3) then list member [0] (the first member) would be 1, member [1] (second) would be 2 and so on. So Gr.GetWinOrg()[0], means the first member of a list returned by the function GetWinOrg() which is a part of the PyVrGr class of which Gr is an instance.

Sym.SetLayer(SymLayer)
Sym.SetGpoint(NorthGraphic)
Sym.SetRad(Gr.GetWinScale()*Radius)
Sym.SetRot(0)
Sym.Plot()
Just set the center symbols visual display based on the attributes decided on above and plot it, again; since GetWinScale returns the scale in units per inch (or mm) we will multiply it out so the display will be set in screen inches.

x,y,z,key = Gr.GetCursor ()
Get the current position of the cursor. This function will really come in handy later, but for now we just want a one time reading of where the current input device is located whether it is a stereo instrument or the mouse.

Line.SetLayer (LineLayer)
Line.SetGpoint (LineGraphic)
Line.AddPoint(Gr.GetWinOrg()[0],Gr.GetWinOrg()[1],Gr.GetWinOrg()[2])
Start by setting the display properties then using the method illustrated above, set the xyz to the window center.

Line.AddPoint (x, y, z)
Line.Plot()
Then add the second point based on the cursor location grabbed earlier, and plot the line.

Sym.SetGpoint(TickGraphic)
Sym.SetRad(Gr.GetWinScale()*.25)
Change the symbol attributes to those used for the corner tics.

for corner in range(4):
There are four corners, numbered 0-3 and the range function will just create a list starting at 0 and ending at the number before whatever is entered. In this case it would return (0,1,2,3). range() actually has a lot more flexibility including setting start point, end point, and increment, but for now we just need a list from 0-3.

..x1,y1,z1=Gr.GetWinCorner (corner,0)
GetWinCorner needs a corner number and a window number, in case there are multiple graphics windows open.
Corner numbers are LL=0, LR=1,UR=2, UL=3

..Sym.SetCoord(x1,y1,z1)
..Sym.Plot()
Plot a symbol in whichever corner is currently up in the list.

..if corner==3:x2,y2,z2=Gr.GetWinCorner (0,0)
There will also be tics at the midpoints between corners, to do this we'll get the average between current corner and next, but if current corner is 3 (UL) then next would be 0 (LL).

..else:x2,y2,z2=Gr.GetWinCorner (corner+1,0)
If the current isn't 3 then get the values from the next corner.
..Sym.SetCoord(((x1+x2)/2.0),((y1+y2)/2.0),z1)
set a symbol at the average between current and next.
..Sym.Plot()
and plot it.

Here are the end results.

Rounding line coordinates

2007-01-29T06:26:00.000-05:00

Things have been a little sparse here, but on the plus side I have made considerable progress on my BeginnersVrPython script. While discussing it with a co-worker it seemed much more productive to just give him some very simple examples to show the absolute basics, digging into the documentation, playing with different functions, and learning python will follow naturally with curiosity. Vr actually comes with lots of great example scripts that would give a newbie everything necessary, I just decided to do this as a way of organizing things I would go over with someone new to VrPython as if I were walking them through it.

Anyway, let's look at another example of looping over all the lines in a file, but we'll narrow it to a specific layer. Sometime later remind me to post my Vr number line parser, but for now we'll work with single layers. The task was that it was necessary to take every line in a particular layer and round the coordinates to the nearest even foot. To accomplish this we'll create a function that will do the rounding when passed a number and rounding factor. For example instead of the nearest foot, the user may want to round to the nearest 100 feet or something similar, so even though the math is easy enough to put in the working code, it will be more flexible if we define a function. This will involve two loops, one to check every line in the file to see if it matches the layer of interest, then if so to manipulate every vertex on the line.

def roundto(NumberToRound,By):
..return (round(NumberToRound/By))*By

import string

Ws=PyVrWs()
Line=PyVrLine()
Gui=PyVrGui()

WsNum=Ws.Aws()
Ws.UndoBegin(WsNum,"round_xy")
input=Gui.InputDialog('Set Layer','Enter layer for box <105>')
if input[1]=='':
..layer=105
else: layer=string.atoi(input[1])

for EntNum in range (Ws.GetLineCount(WsNum)):
..if layer==(Ws.GetLineLayer(WsNum,EntNum)):
....Line.Load (WsNum, EntNum)
....for PntNum in range (WsNum, Line.GetNumXyz()):
......(x, y, z) = Line.GetPoint (PntNum)
......(p, a, c, f, m) = Line.GetPointFlags (PntNum)
......Line.ChgPoint (PntNum, roundto(x,1.0), roundto(y,1.0), z,p, a, c, f, m)
....Line.ReRec()
....Line.Plot()

Ws.UndoEnd(WsNum)

Line by line it looks like this.

def roundto(NumberToRound,By):
..return (round(NumberToRound/By))*By
Straight python here, defining a new function called roundto. It takes a number and a factor for rounding and returns the original number rounded by the factor. Tried and true formula but if it's new for some reason here are some examples.
roundto(106.6,.5) = 106.5
roundto(106.6,1.0) = 107
roundto(106.6,5.0) = 105
roundto(106.6,10.0) = 110
roundto(106.6,25.0) = 100
and so on

import string
There are other more complex ways of doing what I want later, but for this example I really wanted it short and simple which meant using the atoi() function to convert a numeric string to an integer. A good example of why it is helpful to have python installed.

Ws=PyVrWs()
Line=PyVrLine()
Gui=PyVrGui()
Initialize all the Vr objects we will be using.

WsNum=Ws.Aws()
When loading or saving entities it is necessary to specify a workspace number. Typically it would probably be the currently active workspace.

Ws.UndoBegin(WsNum,"round_xy")
Setting an undo point is always a good idea.

input=Gui.InputDialog('Set Layer','Enter layer for box <105>')
if input[1]=='':
..layer=105
else: layer=string.atoi(input[1])
The PromBox functions are actually a much better way of doing this, but it's an old script and I'll throw in those functions at a later date. The if statement just sets the default layer if none is entered, and the else sets the layer if one was. The main problem here is that there is no error checking. If the user enters an alpha character it will just crash, this could be fixed with a try/except test (a very worthwhile subject to look up or discuss later). The other option is just to use PromBox functions, which is what they were designed for.

for EntNum in range (Ws.GetLineCount(WsNum)):
This is only the second time it's been used so let's talk about the for loop. In my mind one of the most powerful features of python is how it handles sequence data, I may discuss it later but the concept of a "list" is, in my mind, one of the coolest parts of python. If I had a list called Alist which contained data [1,2,3,4] and said
for data in Alist:
..print data
I would get the return
1
2
3
4
In essence the for loop is going to work over a sequence of data and process each member, whether it is a list, a dictionary, or a string. If you don't have a list, but just want to run a loop a certain number of times the range() function can build a list of numbers which can be processed. In this case we want to process every entity number from the first to the last up to the limit of the linecount.

..if layer==(Ws.GetLineLayer(WsNum,EntNum)):
However we already determined that only the lines which match the desired layer will be processed. The Ws version of getting the layer is used because it is much faster and it won't even be necessary to load lines that don't match the criteria.

....Line.Load (WsNum, EntNum)
If however it does, load it up to be processed.

....for PntNum in range (Line.GetNumXyz()):
Same idea but this time for every point number up to the limit of the number of xyz coordinates do the following.

......(x, y, z) = Line.GetPoint (PntNum)
Get the position.

......(p, a, c, f, m) = Line.GetPointFlags (PntNum)
Get the flag data, these are extremely useful and important at times for now they will just be preserved, and straight out of the Vr documentation are....
p - Pen code (0=None 1=Up 2=Continue 4=End)
a - Arc flag (0=None 1=Beginning, end or PRC 2=Mid point 3=Point on arc)
c - Code (0-255)
f - Bit encoded flag (0-255)
m - Mosaic width (0-255)

......Line.ChgPoint (PntNum, roundto(x,1.0), roundto(y,1.0), z,p, a, c, f, m)
Using the roundto function defined earlier the point is going to be changed to reflect the new x and new y.

....Line.ReRec()
Of course once it's changed it needs to be re-recorded.

....Line.Plot()
To really be elegant, the line should probably be erased prior to being changed and re-plotted. Many times however I like to to leave both versions on the screen (of course here there isn't any visual difference, I'm speaking in generalities) so I can see something happening or verify a change. A re-plot takes care of it.

Ws.UndoEnd(WsNum)
Close the undo and it's good to go.

All the way to the beginning

2007-01-23T09:37:00.000-05:00

What if you have never learned to write a program in any language, or for that matter had the desire to do so. I'm not really going to post much today, other than to mention that I am working on a script I'm calling BeginnersVrPython.py. I am building it as a reference for anyone in the office that may want to jump right in programming in VrPython without any real knowledge of python. In my mind that is a bit of a limitation because to really get the most out of the language itself, well, you need to know a little about it. There are however an awful lot of things that can be done with even the most basic background. BeginnersVrPython.py will be a guided step through the simplest commands which should prompt the user to get into the VrPython documentation to expand the capabilities. It has always seemed to me that looking at examples, changing them a little, then taking off in varying directions, is the easiest way to learn programming. When done, the beginners script should offer just that kind of examples in a guided fashion. Eventually it will be posted somewhere, but until then I'll just email it to anyone interested in the current state.

Along the same lines of, going to the very beginning, there is another beginners ebook available called "How to Think Like a Computer Scientist: Learning With Python" available. I've looked over a little bit of it and it seems like a good read for someone very early in the game. If you are going to use this, install python 2.5 since that is where VrOne is at as of the current release (3.2 as of 01/07)

Exactly the way you want it

2007-01-11T05:44:00.000-05:00

There are times where Vr gives you all the tools you need to do something, but there may be just a little twist that still makes it worthwhile to write some quick code. In this case all that was necessary was to digitize some locations and have those written to a text file. There are several ways I can think of to do the exact same thing using tools that exist, but in this case there was no reason (or desire) to actually store points in the file, and there was a specific very simple output format desired (which of course could be easily modified for other purposes. This will also give us a reason to interact with a separate external file.

fprintf = lambda afile,fmt,*args: afile.write(fmt%args)

Gui=PyVrGui()
TextFileName='dig'
PointsFound=0
Stat=0

TextFile=open(TextFileName+'.txt','w')
while Stat==0:
..Stat,x,y,z=Gui.GetCoord('Dig_Txt')
..fprintf(TextFile,'%12.2lf%12.2lf%10.2lf\n',x,y,z)
..PointsFound=PointsFound+1
print '\n\a',PointsFound,' Points found and written to file ',TextFileName,'.txt\n'
TextFile.close()

Line by line.

fprintf = lambda afile,fmt,*args: afile.write(fmt%args)
This is mentioned elsewhere as one of my favorite tricks, it exactly reproduces the functionality of the C fprintf statement which formats text for output. Python has some very easy tricks for formatting, this just give me a familiar interface.

Gui=PyVrGui()
Always remember to create the Vr objects you are going to interact with, whether line, symbol, dtm, or in this case gui.

TextFileName='dig'
Points are going to be stored in a file, the name isn't important but let's put it in the block of code that is at the top and easy to find if someone needs to modify it.

PointsFound=0
Stat=0
These need to start at zero so we'll go ahead and initialize them as well.

TextFile=open(TextFileName+'.txt','w')
In this example we'll use the string addition method to add an extension which will end up creating a file named "dig.txt". This is just included to illustrate how if you have a base file name you can open several files with different extensions by just adding a different one. TextFile will become an instance of an open file object in "w" or write mode, there are several modes which mirror their c counterparts. Interacting with files is one of the more helpful actions to pick up. Here we will just be dumping formatted text to an ascii file, but there are times when it will be necessary to read and write from both binary and ascii files, all of which is controlled by the "mode".

while Stat==0:
GetCoord is going to return a status flag which is determined by if the user actually digitized a coordinate or hit End. This loop will just keep it running as long as they keep reading points, and to answer the most obvious question a status of 0 means yes a point was digitized; no I don't know why 0 is yes and 1 is no.

..Stat,x,y,z=Gui.GetCoord('Dig_Txt')
Digitize a point, as a side note the text string there is a title that is said to "show up in the VrOne message area". I have never actually seen it show up anywhere, but something is required to be there and I just enter relevant text in case it ever does.

..fprintf(TextFile,'%12.2lf%12.2lf%12.2lf\n',x,y,z)
The fprintf is discussed elsewhere but suffice it to say the text file we set up is going to get a piece of text formatted to 12 columns, 2 decimal places for each coordinate.

..PointsFound=PointsFound+1
print '\n\a',PointsFound,' Points found and written to file ',TextFileName,'.txt\n'
No real point, I just like to keep track of things like this and print the status when done.

TextFile.close()
Python is supposed to clean up after itself and close files when it exits, but as a rule it is a good habit of always doing the housekeeping explicitly.

Want to just see the least common denominator for a couple of the things mentioned.
To digitize a point, open pyedi and copy in
Gui=PyVrGui()
print Gui.GetCoord('')

Want to write something to a file, do the same (or open a python editor) with the following
file=open('/tmp/tmp.txt','w')#change the directory to something you have
file.write('a line of text')
file.close()

As an addendum, I want to plug a python forum that I mentioned earlier. I can even see it as a place that VrPython users could interact in a conversational way. I enjoy the forum so much that I tend to monitor it on a semi-regular basis and am likely to find a Vr related post fairly quick. Information is power, and sharing it has benefit for everyone. Check it out at The Scripts Developers Network or otherwise known as thescripts.com see you there!

Non-Programmer's Tutorial for Python

2007-01-08T13:41:00.000-05:00

I don't really have time for anything earth shattering here, but if you are brand new to both programming, and Python I highly recommend the site "Non-Programmer's Tutorial for Python"

Need a new command?

2007-01-05T14:48:00.000-05:00

A quick end of week freebie. Here is an example of a really useful program that a person could think themselves justified in griping that it doesn't exist in Vr. Emailing someone and asking for it, looking in each beta release hoping that a life of clean living and good fortune deems that your suggestion is incorporated. OR...... learn a little python and spend 5 minutes writing it yourself. Sure we could each come up with a hundred examples of tools we would like to see, the problem is that half the suggestions on each list would be unique, to which each would say, "How can you want that, this idea is much more important" while at the same time the poor beleaguered programmers struggle to keep up with dumb questions ( note: comic aside which I only mention because I have a string of about 3 for 6 that were total time wasters on the order of "what do I do with the 3 prong cord hanging out the back", to which the answers were still gracious and helpful)

User question: What would it take to write a command that would essentially be insert line in which you ID a line to inherit properties from then start digitizing with the those properties?

How this works is fairly obvious, let me just explain what I think the more elegant points of python are.

Line = PyVrLine ()
Gui=PyVrGui()
Line.Id()
lay,gp,wid=Line.GetLayer(),Line.GetGpoint(),Line.GetWidth()
Gui.PushKeyin ('inslin,lay=%d,grp=%d,wid=%d'%(lay,gp,wid))

We're going to need a Line(), and a Gui() object, then grab the line to inherit from using Id(). What I love is that on the next line we are declaring 3 variables and setting them to the proper values at the same time without ever worrying what kind of variable they are. Then sending the inslin command and all the keyins on one line using python text formatting. So the answer to "what would it take?", not much, cool eh.

Think ahead and start right

2007-01-04T04:09:00.000-05:00

Let me back off a bit and offer some general opinions that may save some time in the end. When I first started playing around with python, it was primarily porting old programs from other languages or mapping utilities from Vr's predecessor. It became almost a game to discover how few lines I could accomplish a task in, and how many basic utilities I could port. After the dust settled a little I realized that I was hooked and would be doing most (if not all) my future programming in python. At this point organization became much more important, but I also had some catching up to do. Here are a few things that helped that I would recommend, pardon as I randomly throw thoughts around.

First, develop a coding style that is consistent. One of the things I like about Python is the ease of use, as a result I am constantly passing code around and encouraging people to use, modify, and learn it. As things get passed around, or when you come back to it months later, a consistent style really helps. It has even made it possible to write a program that parses a script looking for certain cues and then writes an html documentation file for it. As examples of coding style the following aren't necessarily the best way to do things but at least I try to do them consistently and they seem to help.

Keep small reusable code snippets in a module for that purpose. For example I mentioned a Python incarnation of a C-like printf function, I keep that in my personal util module.
When importing and calling a module, I always use the full module name, for example if my printf function is in my dsutil module, I import dsutil then call dsutil.printf() rather than doing a from dsutil import * then just calling printf(). This is a small thing but even for standard modules it always shows where something is coming from.
Have some rudimentary version control. I have a function that prints the program name and last date modified at run time. Very basic, but at least if there is a problem I can ask the user what copy they are running.
I always put a small block of text at the beginning of a script to make notes in, import all necessary modules next, then declare and initialize what I call "variables of interest" that either need to have a particular starting value or which a user may look for at a later date. If there are more generic variables that are just needed to hold values at run-time I generally let those get created in situ. A good example of this would be something like x,y,z=Sym.GetCoord() where there is no need to initialize the coordinates, just let the function create and set them.

Second, document everything. As mentioned above it doesn't have to be fancy but it is amazing how quickly I forget what I was trying to accomplish with a perfectly functional piece of code like.
os.path.splitext(os.path.split(FullName)[1])[0]
A little reminder goes a long way next year when something similar is necessary.

Maintain a simple database of programs written. Just a simple delimited file that contains things like name, function, misc notes, state of completion. With that available I wrote another fairly simple script that parses that file and creates an html document with everything in a table, and links to the files created by the self documented files. In the end if everything goes correct, one program writes the documentation for the script, and another creates the index file from which it can be referenced all based on the information inside the program, or entered in the database.

And just so we don't go too long without a little VrPython code, here are several (though not nearly all) ways to do the old "hello world" program from within Vr. Yes this should have been the very first post, oh well, copy and paste into pyedi and watch the fun begin.

Gui = PyVrGui()

print 'hello world' # to console
Gui.DspMsg0('hello 1') # top Vr status box
Gui.DspMsg('hello 2') # bottom Vr status box
Gui.DspShortMsg(0,'hello 3') # top small status box
Gui.DspShortMsg(1,'hello 4') # bottom small status box
Gui.MsgBox ('hello 5','window title') # dialog popup

Simple task offers many examples

2006-12-28T08:55:00.000-05:00

Let's look at a very simple task that will offer a wealth of examples of using various Vr modules and tasks. This will go beyond the idea of using as a simple macro language into the early stages of writing what I consider true programs that extend Vr functionality and will include some basic ideas as well as some more advanced concepts. This example will include...

using python modules (non-vr straight python)
selecting entities
creating new entities
displaying information in various forms
and grabbing window attributes.

The problem is that there are several lines in the file for which the area is required, along with the total of all areas. It would be nice to allow the user to ID as many lines as necessary, display the area for each line, then present the total at the end. We'll throw in some variations at the end that make for interesting exercises, and more useful programs.

Here is the code....

import math

Gui = PyVrGui()
Ws=PyVrWs()
Gr=PyVrGr()
Line=PyVrLine()
TotalArea=0.0
NumberOfLines=0
text=PyVrText()
text.SetFontNum(4)
text.SetRot(45.0)
text.SetSize(Gr.GetWinScale ()*.15)

WsNum=Ws.Aws()
while Line.Id() != -1:
..TotalArea=TotalArea+math.fabs(Line.Area())
..NumberOfLines=NumberOfLines+1
..print TotalArea
..label='%.1f ac' % math.fabs((Line.Area()/43560.0))
..text.SetText(label)
..(MinX, MinY, MinZ, MaxX, MaxY, MaxZ) = Ws.GetLineMinMax (WsNum, Line.GetLineNum())
..text.SetCoord((MinX+MaxX)/2,(MinY+MaxY)/2,(MinZ+MaxZ)/2)
..text.SetJustX(2)
..text.SetJustY(2)
..text.SetLayer(88)
..text.Plot()

print 'Total Area ',TotalArea,' Sq Units ',TotalArea/43560.0,' acres'
Gui.MsgBox('%d Lines contain %.2f acres'%(NumberOfLines,(TotalArea/43560.0)),'Area by Selection')

Taken a line or two at a time

import math
We are going to use a purely math function later. It would be easy enough to write the function needed (math.fabs() to get the absolute value of a real number), but this illustrates why it is nice to have python installed even though it isn't strictly necessary for VrPython to work, there are times that accessing standard (or very exotic) modules that are already available can be nice.

Gui = PyVrGui()
Ws=PyVrWs()
Gr=PyVrGr()
Line=PyVrLine()
text=PyVrText()
text.SetFontNum(4)
text.SetRot(45.0)
text.SetSize(Gr.GetWinScale ()*.15)
text.SetJustX(2)
text.SetJustY(2)
text.SetLayer(88)
TotalArea=0.0
NumberOfLines=0
First create or initialize all the Vr objects that will be used (first 5 lines), pre-set any entity parameters that the user may want quick access to later (lines 6-11), and initialize variables that need to start with a pre-determined value.
In this case Gui will be used to display a message box, I always initialize Ws out of habit, Gr will give us access to the Vr graphics window, Line will be used to ID line entities, and text will be used to display the areas on the screen in the graphics window as text entities. We'll discuss all these as we use them but text values are declared early and in the variable area I put at the beginning because they directly affect how the text displays and the user may want to change the appearance. The one important thing to notice here is the use of the Gr.GetWinScale to grab the map scale of the current graphics window which is then multiplied by the size (in inches) I want it to appear on the screen since the text object expects size in ground units, also note that SetSize is used rather than setting height and width independently

WsNum=Ws.Aws()
I just always throw this in to make sure we all know what workspace is active.

while Line.Id() != -1:
The line object has a function called Id which not only contains all the overhead of allowing the user to identify a line in the graphics window complete with button dialog, but also returns with that line loaded and ready to work on.

..TotalArea=TotalArea+math.fabs(Line.Area())
..NumberOfLines=NumberOfLines+1
The names give away the purpose, and each time a line is selected we bump the accumulated area and the line count. The reason these were initialized to zeros before is that we want to make sure they start from there.

..print TotalArea
Sometimes I just like to send things to the console screen as a debugging tool or so there is something of a temporary record.

..label='%.1f ac' % math.fabs((Line.Area()/43560.0))
..text.SetText(label)
For this program I decided to display individual line areas in the Vr graphics window as text entities so the first thing that needs to be done is setting the text to the area of the line. Here is where the math module is used to make sure the area is positive. The single quote marks and % symbols convert the floating point number returned to a formatted text string with only one decimal place. If I wasn't worried about the formatting I could also use the python repr() function to simply change the number to a string because the SetText function expects to be handed a string. These two lines could also be easily written as one line but that makes it a little more obscure for this example.

..(MinX, MinY, MinZ, MaxX, MaxY, MaxZ) = Ws.GetLineMinMax (WsNum, Line.GetLineNum())
Since the text needs to be place somewhere on the screen, I decide to just place it in the middle of the lines extents. In order to do that we need the Mins, and Maxs. Those values are stored with the line header in the workspace so within the workspace object Ws we use the GetLineMinMax on WsNum (which we set to the current earlier) to pull the data for the entity number of the currently loaded line.

..text.SetCoord((MinX+MaxX)/2,(MinY+MaxY)/2,(MinZ+MaxZ)/2)
Once we have the extents just take the average and set the text to be displayed at those coordinates.

..text.Plot()
The have Vr plot the text entity on the screen. Note that there is no save done on the text so if the screen is refreshed or overwritten it will disappear.

print 'Total Area ',TotalArea,' Sq Units ',TotalArea/43560.0,' acres'
When the selection is all done (note that we are out of the indented block) print various numbers and text to the console screen for the same reasons listed above..

Gui.MsgBox('%d Lines contain %.2f acres'%(NumberOfLines,(TotalArea/43560.0)),'Area by Selection')
More importantly display it all in a message box that will come up nicely formatted and with an "OK" button to dismiss.

Variations include:
Prompting for a layer number and just summing the areas for all lines in a given layer rather than selecting them.

As the lines are selected, how about changing some graphic attributes (again don't save anything) that make the line stand out so it is obvious which lines have been ID'd.

As lines are computed the individual areas along with some identifying info (entity number, or feature code) could be written to a file followed by the total.

Fix it so that if the user identifies the same line multiple times it only gets added to the total once. (caution geeky hint: I would probably use the entity number, a list, and the list.count function)

Quickie tip

2006-12-19T15:24:00.000-05:00

Already posted for the week but found a forum that shows quite a bit of promise. It is at TheScripts developer network, and looks pretty interesting.

Python as macro revisited

2006-12-19T06:23:00.000-05:00

In the first VrPython example I gave which has now take on it's official name of fix_sym_z.py my purpose was to show how it is possible to get some working code very fast just using some basic Vr keystrokes. I very rarely use the vr button (B1, B2, B# etc) commands to actually push the buttons, but it makes a point. The real problem with that script in a public setting is the drive point functionality that wasn't explained, not to mention that the person using it had several key suggestions to make it much more useful (don't end users drive you crazy like that sometimes). In any case, let's look at the current evolution of the script and the positive and negative effects of the changes. While I'm still going to use the button press commands at the end to actually do the work, by necessity this will start looking more like a python script and less like a simple extended macro, but then that's the whole point.
Remember the dots are used for place holders and to visually represent the indentation which is life and death in python (2 dots = 1 tab)

Gui = PyVrGui()
stat=0
Layer2Drive=25
Sym=PyVrSym()
Ws=PyVrWs()
WsNum=Ws.Aws()

Gui.PushKeyin ("digxyz")
for EntNum in range (Ws.GetSymCount(WsNum)):
..if Layer2Drive==Ws.GetSymLayer(WsNum,EntNum):
....Sym.Load (WsNum, EntNum)
....x,y,z=Sym.GetCoord()
....Gui.PushKeyin ('xyz '+repr(x)+' '+repr(y)+' +0')
....stat, x, y, z = Gui.GetCoord ('Select Coordinate')
....if stat==0:
......Gui.PushKeyin ("chaele")
......Gui.PushKeyin ("sealin=0")
......Gui.PushKeyin ("seasym=1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b#")
......Gui.PushKeyin ("chalay")
......Gui.PushKeyin ("sealin=0")
......Gui.PushKeyin ("seasym=1")
......Gui.PushKeyin ("lay=76")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b#")

Looking at it a line at a time

Gui = PyVrGui()
stat=0
Layer2Drive=25
Sym=PyVrSym()

As before, just setting up some variables. Creating an instance of the Gui object, same for a Symbol, and initializing the others. This is a good place to note that in Python you don't actually have to declare variables, or initialize them in any particular place. I could have put the Layer2Drive=25 on the line right before the first place I used it, or if it were the result of a calculation, just let it be created in place. I am only setting them up early like this because I want to know what they are set to, and putting it all together seems like sound practice. In the first pass at this script the external "drv2lay" script prompted for the layer, but in reality the user just wanted it to always use the same layer. I could have used the desired number rather than a variable later, but using a variable and setting it at the outset makes it easy for other users to find and change if they want.

Ws=PyVrWs()
WsNum=Ws.Aws()
Gui.PushKeyin ("digxyz")
Because Vr allows several workspaces to be open at the same time and in many cases you have to specify which one you are interacting with you need to create an instance of a workspace object, and in this case set it to the currently active workspace. Then let's make sure that the stereo digitizer is active before we start driving to points.

for EntNum in range (Ws.GetSymCount(WsNum)):
....if Layer2Drive==Ws.GetSymLayer(WsNum,EntNum):
This is going to represent one of the biggest changes to this script, driving to the points will actually become part of the script, but before we can drive, they have to be identified. The for loop in Python is fantastic and I won't take time to explain it now (remember the books recommended in the introduction). Let's just say that in plain English these two loops (the for and the if) would sound like "For entity numbers in the range zero through how ever many symbols there are, if the desired layer to drive to is equal to the layer of the symbol with the entity number currently being checked". Yes we are going to loop over the entire file and check the layer of each symbol, the power behind this loop is the way the checking is done which I won't really go into, but suffice it to say it seems instant on even the largest files.

....Sym.Load (WsNum, EntNum)
....x,y,z=Sym.GetCoord()
At this point if the symbol does match the layer we plan to drive to, load the symbol based on the workspace we are working in, and the entity number of the symbol currently being checked. Then from the loaded symbol grab the coordinates. Note that since GetCoord returns 3 numbers, I can assign all 3 at the same time. This is also an example of assigning data to a variable that has been neither declared nor initialized. It becomes a floating point variable because that's what I assigned to it.

....Gui.PushKeyin ('xyz '+repr(x)+' '+repr(y)+' +0')
Once I have the coordinates I can drive the instrument using the Vr command 'xyz' then supplying an x, a y, and the +0 just means rather than an absolute z use one relative to the current position and add zero. Since PushKeyin expects a string we have to construct one using a text+text method. In this case since x and y are numbers, they have to be converted to text before they can be added to the string using the Python repr() command. There are some extra spaces inserted after the xyz and before the +0 to keep things separated, so if x was 1.0, y was 2.0 the final string pushed to vr would be.
xyz 1.0 2.0 +0

....stat, x, y, z = Gui.GetCoord ('Select Coordinate')
....if stat==0:
Once the appropriate symbol has been found, and the instrument has been positioned there, use the same method as before to pause for the operator to put the dot on the ground and digitize the elevation at that point. The main difference from before is that now if the user digitized a point all the changes will be made. If they hit end, rather than abandoning the whole script, it simply doesn't change anything and continues looking for symbols that match the layer criteria. There really isn't any way to abandon the script, but in this case the user wanted it this way.

......Gui.PushKeyin ("chaele")
......Gui.PushKeyin ("sealin=0")
......Gui.PushKeyin ("seasym=1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b#")
......Gui.PushKeyin ("chalay")
......Gui.PushKeyin ("sealin=0")
......Gui.PushKeyin ("seasym=1")
......Gui.PushKeyin ("lay=76")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b1")
......Gui.PushKeyin ("b#")
Same basic set of changes, except that before we waited until the elevations had been changed, then globally changed the layer to put it in the dtm data set. Now since if there is no point digitized, no changes are made, we can put the layer change right into the symbol modifications which includes everything including and after the chalay line. Note that I hard coded the layer to 76. As I write this I'll probably change that to a variable for the same reasons I mentioned for the layer to check. The parameter for the PushKeyin will be something like..
("lay="+ChangeToLayer)
There won't be a repr() command because I'll just store the variable as a string in the first place, something like...
ChangeToLayer='76'

All in all still much more brute force than elegance, but now we are doing some basic looping over entities including loading and pulling information from them.

2006-12-15T11:31:00.000-05:00

I really only plan posting about once a week. I've already decided that the next "real" post will work on cleaning up the Vr script (which has come to be known as fix_sym_z) I mentioned earlier to make it much more useful and fully independent of the drive functions. However this quick one is just too cool to wait. But just in case the corpscon stuff is totally worthless to many folks who plan to write python in Vr, let me pass along one of my favorite tips, as pasted from one of my utility modules (dsutil). While the comment sections explain what it does, you may want to look up lambda, though it isn't necessary. If you understand printf, you understand this function.

printf = lambda fmt,*args: sys.stdout.write(fmt%args)
'''
c like implemetation of printf, for example:
dsutil.printf("this is %s test with the number %.2lf",'a',9)
yields...
this is a test with the number 9.00
'''

fprintf = lambda afile,fmt,*args: afile.write(fmt%args)
'''
Same as printf but like c's fprintf sends output to open file

usage: dsutil.fprintf(AnOpenFile,"format",Values)
'''

Tom Blankenship is pretty high in my relatively short list of amazing programmers I actually know and can glean information from. As usual, if it is a matter of education on coding practices, Tom was fast to weigh in. The corpscondll is pretty well documented but my problem was that I didn't know (and didn't know that I didn't know) how to pass a c style double pointer using c_double(). Tom put together a working script that has all the information necessary to incorporate corpscon transfomations into production programs, is this stuff amazing or what.

As always a big thank you and hats off to Tom.

2006-12-14T15:02:00.000-05:00

There is a patch up that includes python 2.5. I have installed it and want to make a quick report.
The main implications include the facts that I...

Rely heavily on standard imported libraries.
Have lots of my personal modules containing generic utilities.
Program everything in python and need to compile exe files in many cases.
Utilize several open source libraries like PIL, pyserial, etc.

Before I installed the patch, I un-installed all python 2.2 libraries as well as python itself. I then installed the patch and played with vr a little to make sure that everything worked the way it should. Next I installed python 2.5 and my most used extra libraries (primarily pywin32, PIL, py2exe, pyserial). So far everything is working out fine except that I couldn't easily get py2exe to work the way it always did. I'll admit that I didn't spend a huge amount of time and it is my problem, I just got frustrated trying to figure out how to configure everything to eliminate the message "LoadLibrary(pythondll) failed" when running a program without the full path. It works fine on simple programs, but there is apparently something in the way I code that is causing problems.

While screwing around I found that pyinstaller worked fine for what I was doing and I was able to get it running in just a few minutes, so I'm going to migrate there for now.

So far I'm quite pleased with the results of the upgrade. I've got as much weird stuff going on as most people so if it works here, I would think it would work for most anyone and I would suggest going for it.

No major earth shattering changes but I like being on the latest python in case I find new libs I would like to use. I'll also toss out that in 2.5 ctypes is included in the standard install. My hope would be that this would make it possible for someone who knew what they were doing to use external DLLs. So if you know of a way to use the corpscon DLL to write a coordinate transformation function within program, I would love to hear from you.

2006-12-11T17:28:00.000-05:00

I'll come back to learning python but thought I would toss in a little Vr as well. Had a situation where a colleague wanted to perform a fairly simple and repetitive task. When it came right down to it Vr already had most of the tools he needed, I thought about stringing it together into a macro for him, but realized that some conditional statements would add a little zip to the solution. In the end the solution is a good example of just using python as an extended macro language. Nothing earth shattering, just using basic Vr commands, but putting a little of the power of python behind them.

The situation was that he wanted to be able to quickly and visually throw points into a file in a random pattern using the mouse. Then to make these same points part of a valid 3d data set he wanted to have the instrument drive back to the points, pause for the dot to be placed on the ground, set the elevation of the symbol to the current instrument position, then go on to the next point without having to issue any command other than ending the id process.

The outline of the solution goes as follows.

Digitize the symbols in a layer that makes them unique.
Capture the xyz locations of those symbols by looping over the points in the file.
Loop over the locations with a process that

Pauses to digitize a new z at each location
Set the symbol to that elevation.
Drive to the next point.

When all done globally change the symbols to make them part of the normal data set.

I'll address a couple of the redundant or wasteful portions of the solution later, but to some extent this will also expose that fact that sometimes I write ugly code just to get something out for testing in a fairly short time, I regularly go back when things are slow and tighten up procedures. This one definitely qualifies as one of the ugly ones, but it's still a good example. Keep in mind that to this point I haven't found a way to make the proper indentation persistant in this blog so until further notice I'll use periods to fill the space where indentation belongs. Lets look at the code line by line...

Gui = PyVrGui()
stat=0

Gui.PushKeyin ("py drv2lay")
Gui.PushKeyin ("digxyz")
while stat==0:
..Gui.PushKeyin ("dri")
..stat, x, y, z = Gui.GetCoord ('Select Coordinate')
..if stat==0:
....Gui.PushKeyin ("chaele")
....Gui.PushKeyin ("sealin=0")
....Gui.PushKeyin ("seasym=1")
....Gui.PushKeyin ("b1")
....Gui.PushKeyin ("b1")
....Gui.PushKeyin ("b#")

Gui = PyVrGui()
This one just imports the appropriate library that will do most of the work in this script.

stat=0
The routine used to grab the current instrument position returns a list which includes the process status to evaluate whether the used in fact digitized a point or just hit end.

Gui.PushKeyin ("py drv2lay")
This is the most obscure part of the code. I already have a script that asks the user for a layer number (or number line), creates a drive file containing a drive point for every symbol in that layer, then opens the drive file. I will discuss that program in a later post but for now any function that grabs the xyz values for every symbol in a pre-determined layer would be fine. I chose to go the drive route so the values would be stored temporarily, and I could just use the Vr "dri" function later. "PushKeyin" just sends the string in quotes to the Vr command line as if the user had typed it

Gui.PushKeyin ("digxyz")
Because the first time someone used it, they started the program while still set to the mouse which had been used to digitize the symbol locations, as well they should. Just need a toggle it over if it hasn't already been done.

while stat==0:
Python flow control is fairly standard, In this case if the user hits "End" rather than digitizing the new elevation at the symbol position the routine would return a 1, so if this happens "game over".

Gui.PushKeyin ("dri")
In the actual work part of the loop the first thing we want to do is drive to the next valid coordinate position, remember that there is already a drive file open with all the positions I want because of the other python program I called earlier.

stat, x, y, z = Gui.GetCoord ('Select Coordinate')
Once we get to the position, pause and wait for the operator to put the dot on the ground and hit the button sending a status code and especially important the new Z.

if stat==0:
There is probably a more elegant way of doing this, but the fact is that after the user digitizes a point I needed to know if they had hit "End" and if so just skip the rest. If they digitized a new z location I want to do the following using the keyin routine.
chaele - start chaele because that's what I actually want to do.
sealin=0 - make sure that line search is off.
seasym=1 - make sure symbol search is on.
b1 - hit button 1 to identify the symbol at the location where the instrument is sitting.
b1 - hit button 1 to release the point.
b# - hit the # to end chaele and resume the loop which then drives to the next point.

So in this example I'm just using python to create the drive list, and the control flow to loop over it. I could also turn off any layers that aren't necessary to make sure that nothing errant gets identified. It could also have been done in one step without the second loop by not creating the drive file, but simply making a go to xyz statement part of the first loop which identifies the proper points.

2006-12-08T16:43:00.000-05:00

I'll admit that when I get new hardware or software I'm the kind that installs and just jumps in with both feet playing and experimenting. I've always thought that it is much better to get into the documentation with at least a basic grasp of what interfaces and such look like. At the same time though I am a huge proponent of structured progressive training. That is really where I'm headed right now with the following recommendations.

For anyone that is already programming in another language I think it is worthwhile to install Python on a computer even though it isn't strictly necessary for VrPython. I actually think it's a good idea for anyone, but if you just want to jump into VrPython, skip this for now you'll probably find other posts more helpful.

As of the time of this writing the current implementation of Python in Vr is 2.2. If that is what is installed then an extension called pywin32 which not only adds windows elements to Python, but also includes an editor and programming environment that I like much better than Idle.

Once you have the current Python that matches whatever is built into Vr, I recommend the following books. Skip any reference to gui programming and tkinter for now.
For basics start with.
"Sams Teach Yourself Python in 24 Hours"
"The Quick Python Book"
For more advanced reference.
"Python Essential Reference"
"Python Cookbook"
I actually found all of them at my local library, though I like them so much I bought the last 3 to have around as a reference. I would read the first two at the same time or in that order. "Quick Python" was amazing in the information you can pick up fast if you have some programming experience. It is especially helpful for someone who might switch over to Python for routine programming. Pay special attention to the concept of lists, I think they are by far one of the coolest things available in Python, and will offer a lot of power as time goes by.

Why would a person want to switch to Python? Well for me it came down to the fact that I was spending time in it on a daily basis within VrOne anyway. Now with the introduction of the "pyedi" command, coding within Vr is even more convenient. However the more time I spend with it the more powerful and fast coding in this environment seems. I decided to try rewriting some basic file manipulation programs and found that the lines of code dropped to about %25 of the original once I switched from something like C++. The more I tried, the less restrictions I found, for example by adding libraries like PIL (Python Image Library) I was able to write a program that applies an external level file to an image. Sure I have that in ImageUtil, but I had mine a year earlier, and on every computer I own. So programming in general, and certainly Python, isn't for everyone, but it is a great place to start for beginners, and pure fun for those more experienced, in my opinion anyway.

2006-12-06T05:46:00.000-05:00

By way of introduction let me just mention that I have been working with Vr or it's noble predecessor since 1989. While I always have suggestions on how it could be improved, I am not going to apologize for how much I like this software, or the fact that at times I may sound like too much of a cheerleader for it. I have no relationship with Vr other than satisfied customer, and have nothing to gain from the time spent here other than providing an outlet for my enthusiasm for programming and making maps. If anyone has some good tips or information that get passed along to me then that would just be a wonderful plus.
My first introduction to computers as a working tools were HP-UX workstations, collecting data in CADMAP, and programming in C. Over the years I have had the fortune to migrate to C++ and now to Python. I have never been particularly clever or ambitious in my programming, but simply see it as a tool to take the task at hand, and either make it possible, or easier. I have the blessing to work in an environment that encourages me to think, code, and experiment. Time spent learning and improving practices is considered time well spent. Thankfully most of the limited knowledge I do have about good programming flow and practices came from early discussions with Mike Kitaif who ranks up in the top handful of the sharpest people I personally know. I will go ahead and credit any good looking code I happen to come up with to him, though to be honest, most of it is just throwing something together to get a job done.
My thoughts at the moment are to ramble a little about Python, VrPython, and Vr in general. I am a huge fan of stretching the capabilities of Vr with Python. I may mention some of the 100+ tools that we have developed for specific tasks and need to be careful to say that I don't consider this to be an indication of anything Vr is lacking, rather that while offering one of the most user friendly, practical, powerful data collection environments "out of the box", it goes beyond that to offer a potential for power and customization that is truly incredible. Not everyone would like the tools I like, but the beauty is that if not, they can create their own, and if they do the same tools are only minutes away with a few lines of Python.
I have over time have begun to do all my coding in Python and also hope to share some of the ways it can be useful to folks to go ahead and install the full system and find uses for it.