Hello World

Point in Plane (finally)

2011-12-23T18:33:00.000-08:00

One of the last things I've been stuck on is figuring out if a point is within a plane in. After playing around with nearestPointInMesh a couple days ago, it seemed that the function was designed to determine if a point was inside a 3-dimensional mesh rather than a 2D plan (though I still consider that a mesh), which let to a few days of frustration and misunderstanding.

I ended up coming across Jeren Chen's code on determining if a point is inside a mesh without using plug-ins (which I really prefer since you shouldn't assume your user has all the plug-ins you do). His code, like the Maya plug-in, functioned on a 3D mesh rather than a 2D plane, but I ended up writing a hacky function that takes in a plane, moves it down the y axis a tiny bit and extrudes it upwards twice that amount to form a "buffer" 3d mesh for that plane. And then I called Jeren's code. For those wondering it looks like this:

def pointInPlane(v, p):
    # convert point to MPoint
    m = MPoint()
    coord = cmds.xform(v, q = True, ws = True, t = True)
    m.x = float(coord[0])
    m.y = float(coord[1])
    m.z = float(coord[2])

    # copy the given plane (since we'll be extruding it and deleting afterwards)
    plane = cmds.duplicate(p)

    # select all faces on the plane
    cmds.select(plane, r=True)
    cmds.ConvertSelectionToFaces()
    f = cmds.ls(sl=True)

    # move plane down a bit and extrude upwards to form a thin "buffer" mesh for the pointInMesh function
    cmds.move(0, -0.05, 0, plane, a=True)
    e = cmds.polyExtrudeFacet(ty=0.1)

    # get the resulting polygon
    poly = getPolyFromFace(f)

    # call pointInMesh function
    inside = isInside(m,poly)

    # delete the copied poly
    cmds.delete(plane)

    return inside

Hacky as it is, it works (yay!)

Bug Fix + Self Note

2011-12-22T00:30:00.000-08:00

I found out that running my code on a computer that wasn't my laptop would result in the trees not being able to load, since in my code I had specified them via an absolute file path. Just fixed that by making a new function that would find the current file path via python's os module, and navigate into the assets folder. Just as a self-reminder, the command to find the path of the script that's running is:

return os.path.abspath( __file__ )

Making the GUI

2011-12-16T22:29:00.001-08:00

Most of the GUI has been implemented! Right now the GUI is separated into 3 tabs, with the first one controlling all map-related functions (such as subdivision), the second one controlling all building-generating parameters, and the third one displaying a map of color to asset name (still in progress). As of now I'm able to generate buildings via the GUI.

Thinking about also including a color editor in the GUI so the user doesn't have to navigate to Maya's Color Set Editor to change the faces.

Also, I'm still working on figuring out if a point falls within a plane. Joe suggested I use the closestPointOnSurface command, but that seems to be a plug-in that happens to be missing from my version of Maya, and I can't find a download for it at the moment. I have, however, found a nearestPointOnMesh command in my plug-in directory, so I'll be looking into that tomorrow.

I heard you like faces, so I put a face in your face...

2011-12-12T22:07:00.000-08:00

Working on implementing subdivisions right now. One thing I've come to notice is that depending on how the face is generated (ie. via the interactive split tool or cut faces tool), running the same subdivide command can generate different results.

For example, in the instance below, I'm trying to add split each face into 4 sections in the u-direction. Some faces split fine, others aren't affected at all.

Direction-specific splitting. Some faces unchanged.

One solution I've found is to split each face recursively*, rather than in a particular direction. Though this offers slightly less control over how the faces are split, it does manage to affect every face.

*With divisions set to 3 in quad mode, each initial quadrilateral will be recursively subdivided into 4 subfaces 3 times, yielding a total of 4 * 4 * 4 = 64 faces.

Recursive splitting. All faces modified.

While it is possible to implement directional subdivision, it would require the user to refrain from using certain tools in generating the map. Between the two choices, I decided in favor giving the user the more freedom while retaining basic functionality.

Self Evaluation

2011-12-04T14:47:00.000-08:00

It's time for some introspective self-evaluation.

Looking back on my initial proposal, I realized that starting out, my goals weren't very clear. There are two types of procedural generation when creating a city—the generation of the individual building, and the generation of the whole city from many buildings. At first I had planned to tackle both these problems, but combined with a rather steep learning curve for MEL, this proved to be a bit too ambitious. It's fair to say that I underestimated how long it would take to really understand how MEL worked and how to manipulate objects through MEL effectively. After getting feedback from my Alpha Review, I stepped back and reevaluated my project. This led to a change in direction that I feel was ultimately a positive turn for my project. I decided to focus on the generation of a whole city, since it allowed for more artistic experimentation (generating the different building types), as well as a more practical final product.

While my current project is fairly different than what I had originally envisioned, I'm quite happy at how it turned out. Here is a list of features I have today:

Ability to generate buildings from either faces or polygons
Established framework for adding additional types of buildings
Generation of different building types depending on face color
3 different types of assets: residential, business, trees
Ability to import additional assets as Maya ASCII files
Setting max/min height of generated buildings (currently hard-coded)
Setting cell width of building windows (currently hard-coded)
Generation of random types of roots/details on buildings

Please see my previous post for features I'm planning on implementing the next few weeks. Eventually I'm hoping to create a script that's easily extensible so users can have more control over what types of assets are generated (ie. a backyard with different types of plants instead of being limited to a city)

Beta Review and Future Plans

2011-12-04T13:03:00.000-08:00

I had my Beta Review with Norm and Joe on Friday, and I'd say it went over pretty well. I implemented Norm's suggestion on color-coding building footprints to determine the generated structure type, as well as importing external Maya ASCII files into the library of available assets. Results-wise, I was able to generate a city with multiple building types as well as trees (imported Maya ASCII files), which I was pretty happy about.

The Beta Review also gave me some ideas to work on the next few weeks. One was finding a rectangle that can fit completely within a convex polygon. Prior to this, I was generating each footprint by shrinking the bounding box of its containing face by a random value, but in some cases (such as when the polygon is a triangle), the resulting footprint can still fall outside of the face. Another feature we thought of during the review was to subdivide a face into smaller components so the user can generate multiple smaller assets close together.

With the end of the semester coming close, here is a list of features I'm working on having done in the next few weeks:

Must

Generate a GUI for the users
Implement rectangle generation within convex polygon feature
Implement face subdivision
Refine building structures

Optional

Implement user import of assets (as part of the GUI)
Add additional building types

Dec 4 - 10

Implement rectangle in convex polygon
Implement face subdivision

Dec 11-17

Refine building structures
Create GUI

Dec 17-21

Finish optional implementations if time permits
Movie presentation

We're in Business!

2011-11-29T13:48:00.000-08:00

Added a new business building type. Still have to refine the structure. Also added user control over what types of building to generate on a face (video will be up after beta review). My beta review got delayed, so I'm hoping to stick in a few more building types by then.

Roofs

2011-11-27T00:18:00.000-08:00

Added ~5 roof variations. Need to fix footprint generation when the given lots aren't rectangular, which is a maximal rectangle problem. Here's to hoping Maya has some kind of function for that.

Mini-City!

2011-11-26T01:11:00.000-08:00

Some updates for the week:

Implemented functionality to generate buildings given either a selected face, multiple selected faces, a one-faced polygon, or a multiple-faced polygon. This will offer a lot of flexibility for the user when they are selecting regions to generate buildings
Fixed window extrusions
Altered a big chunk of my original framework for floor-generation. Before, my code would generate one floor, and return the top-most face. The subsequent function would take that face, duplicate it as a transform node, and extrude from that. The problem I ran into with this method was that, in cases where I subdivided the side faces for making windows, the resulting face that I returned would have all the excess vertices on its sides (imagine a square with a vertex for each corner, and then ten more vertices spaced evenly on each side). This was undesirable, since my code assumes that the footprints passed in are "clean" (as in, without necessary subdivisions). I fixed this by making each function duplicate the resulting face as a polygon/transform node (using a helper function I wrote). This way I can create a duplicate footprint before adding windows to the original one.
Figured out how to import Maya ASCII files into a scene in python. I'm planning on letting users import their own assets eventually
Improved the building-generation flow in the code. The code stores all the faces in a list (if there are multiple faces to work on). For each face, the ground floor is generated first, and the rest of the floors are generated in a for-loop. Each level is split into two additional functions-- createLedge and createFloor.

Some things I'm hoping to finish before the beta review are:

Port over the GUI code (right now all the values in Python are hardcoded; the GUI is still in MEL)
Create functions for roof-generation
Create generation functions for different building types
Start functionality for reading in an image file and mapping it to cells on an input map
Add more variation

Making Windows

2011-11-21T00:47:00.000-08:00

Spent the weekend fixing the the conflict between column generation and building base extrusion. I ended up keeping the initial footprint as a polygon with no subdivisions and creating the columns and base as such:

inwardExtrude to create the actual footprint the building will be generated from (this is to give "sidewalk space")
Add subdivisions to the newly created footprint. Right now it's set to 10x10, but in the future this value can be pulled from the GUI
Select the outer ring of faces for column generation.
ShrinkPolygonSelection (this command took a while to find) to select the inner cluster of faces. I wrote a helper function called deleteSubdivisions to remove the subdivisions for the building base extrusion. The reason for removing subdivisions is keep each wall face clean, so there are no conflicts when I do need to subdivide each face according to how many windows there should be.
Finally we can extrude the building body to the height of the columns to get something like this:

Moving on to the floor generation, the hardest part was to figure out how to select the faces I needed, and how to subdivide each face properly. I actually started this portion earlier this week, except the lack of documentation for polySubdivideFacet led me to believe that it wasn't possible to subdivide in only one direction (ie vertically). Coupled with the fact that maya commands in the actual interface are named differently than the ones in the documentation, I was running around in circles for a few days before figuring out that you actually can subdivide a face in one direction (I ended up trying the Add Divisions tool in maya and realizing it was indeed calling polySubdivideFacet).

That being done, the next step was to scale/extrude each cell to form the frame of a window. From looking through a bunch of other people's code, I learned that polySelectConstraint was the best way to isolate the faces I wanted (ie. all faces on the east side of the building). That being said, I ran into a bug stemming from the fact that I was running transformations on faces that were passed in. I hadn't anticipated the fact that when you iterate through each side face of a floor and subdivide it, you end up with more faces than you started with and trying to keep track of everything by explicitly naming faces becomes much more difficult. So somehow I ended up with this:

Lots and lots of windows

I'm pretty sure I know what needs to be fixed, so this should be good to go by tomorrow. The windows were the last step to the floor creation function, so once that's done I should be able to create a building by calling createFloor numFloor-many times.

Some takeaways:

I feel that the majority of my time up until now has been spent on overcoming the rather steep learning-curve of knowing which maya commands to use to do what you want. I've also become more aware the the flexibility we can get by switching between vertex, edge, and face perspectives (a lot of the helper methods I wrote this weekend utilized this). Previously I was a bit hesitant to post pictures, since I felt what I had was rather lacking given the time that had passed. However I've realized the ramp-up time I took was worth it, since I feel a lot more comfortable coding for maya now, and my productivity has gone up quite a bit.

Just for my own reference (in case all 300 of my tabs crash), here are the Maya commands I find myself using the most:

polyEval
polyExtrudeFacet
polyCreateFacet
polySubdivideFacet
xform
polyListComponentConversion (or just cmds.ConvertSelectionToFaces())
polySelectConstraint
polyChipOff
polySeparate

Adding Details

2011-11-18T00:32:00.000-08:00

Most of this week was spent on looking through sample scripts to see what command patterns other people use to generate building details. One thing I've realized is that although I'm fairly comfortable with MEL and python commands in Maya at this point, I still lack a lot of the experience that comes from long-term use of the languages. The most difficult part for me is knowing what commands I should use for a particular task. For example, the code I had before the alpha review had attempted to move the pivot of a model by using the move command in MEL. Now I know the the proper way to go about it is to use the xform command instead, since there is a scalePivot flag specifically for this operation. The python function I wrote for this looks like :

def movePivotToBottom(obj):
    piv = cmds.xform(obj, q=1, ws=1, scalePivot=1)
    newY = cmds.getAttr(obj + '.boundingBoxMinY')
    piv[1] = newY
    cmds.xform(obj, ws=1, scalePivot = piv)

I've written a few helper functions like this one that have been helping me understand the maya commands better. Something else that confused me for a while is the difference between, say cmds.scale(...) and cmds.setAttr(... + '.scale'). I've tried running both of them, and from what I can tell they both do the same thing. I just haven't figured out circumstances under which each command is advantageous.

Another thing I've realized is that there are MEL commands that aren't found in the online documentation at all. After a frustrating few hours, I found out from a forum that these are either run time commands, or procs that come with maya. To check, you can run whatIs , and Maya would either tell you it's a run time command, or give you the path to the file containing the proc. At first I was worried that I wouldn't able to use certain commands/procs in python, but the maya.mel.eval command saved the day.

I'm almost done writing the function that adds columns to the base of the building. One problem I'm trying to fix right now is that the column-generation code relies on the subdivision of the footprint mesh, and my building-body mesh runs on the assumption that the footprint doesn't have any subdivisions. I'm planning on just making a copy of the subdivision-less footprint, adding subdivisions, and deleting it after the columns are generated. The only remaining problem is to make sure the columns are never intersecting with the building body, which I hope to solve by tomorrow. As I become more familiar with what I like to call "design patterns" for creating building assets, I hope to speed up my process and have images ready by the next update. Until then, stay tuned!

Some Change in Direction + Updates

2011-11-14T13:56:00.000-08:00

One of the comments that really stuck with me from the alpha review was why bother creating a building generation script so similar to City Engine, when City Engine already exists. I spent the weekend re-evaluating my project, and came up with some changes that I feel would set my project apart from most of the existing building generators.

The majority of building/city scripts focus a lot on generating sufficient randomness, so the city doesn't look repetitive. Because of this, the user usually doesn't have a lot of say on what types of architecture should be generated at a particular location in the city (in CityEngine this is doable, but requires scripting on the user's end).

I felt this would an interesting issue to address, so I decided to alter my project a bit, such that it focuses on generating a city with different building types, located according to user specifications. I started out identifying three basic types of architecture that exist in a typical city: business buildings, residential structures, and recreational areas, and listed some of their properties below.

During one of my review sessions, Norm had suggested the use of a heat-map to specify the placement of different architectural styles. Using that as my start-off point, I plan on having my project take in an image from the user, with each component of the RGB value corresponding to a building type. For example, R = business, G = residential, B = recreational. For colors that have multiple values, I can determine the building type by the dominating RGB value, or by a probability function. This will allow my project to be extensible; additional building types can be added anytime as long as an RGB pattern is specified.

Since Python has an excellent image processing library, I decided to continue my project in python from now on. Currently I'm in the middle of porting my code from MEL to python and thinking about setting up an inheritance structure (if any) for the different building files.

Some links that were really helpful in getting me up to speed with python/maya was Chad Vernon's tutorial site and Autodesk's list of python commands in Maya. Check back in a couple days for more updates.

Wrangling the Maya Plug-in Wizard

2011-11-06T18:04:00.000-08:00

This week I started exploring the Maya plug-in for Visual Studio. Since the whole process took a while to figure out, I thought I'd document the steps I took in case someone else needs it later. The basic set of instructions can be found on the autodesk site here, but additional steps are needed to make everything work (which I will mention below)

The MayaPluginWizard.zip file is found in the devkit/plugin folder under wherever you installed Maya (for me it was C:\Program Files\Autodesk\Maya2012\devkit\pluginwizard). From there, open the MayaWizardReadme.txt, which will give you step by step instructions on adding the plugin wizard to VS (take note there are different instruction sets for 32 and 64 bits.
Unzip the MayaPluginWizard.zip file (I had to copy this onto the desktop first due to permissions). After navigating into the extracted directory, open the MayaPluginWizard.vsz file in a text editor like Notepad++, and make sure Wizard=VsWizard.VsWizardEngine.9.0 refers to the correct version of Visual Studio (VS2008 is 9.0 so I didn't have to change anything).
Copy the following files to the "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcprojects" directory:
    MayaPluginWizard.vsdir
    MayaPluginWizard.vsz
    MayaPluginWizard.ico
Copy the *outer* "MayaPluginWizard" directory to "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\VCWizards". NOTE: there should be a MayaPluginWizard directory within a MayaPluginWizard directory after this step.
Now, since my version of Maya2012 is 64-bit, and VS is 32-bit, I needed to configure my VS for 64-bit applications. I followed the directions listed here (basically you need to install the missing x64 compiler and tools). This requires you to have the VS installer on hand, which was a pain.
Close VS if you have it open. Right click on the icon and select "Run as administrator". If you don't do this, you'll get an extremely vague popup saying "project upgrade failed". Figuring out this part was extremely frustrating.
Now you should be able to create a project using the Maya Plugin Wizard. (Start Microsoft Visual Studio 9.0 and invoke File -> New -> Project -> Visual C++ Projects and select MayaPluginWizard.)
The project will be created and then the solution can updated and built.

Alpha Review Thoughts

2011-11-04T20:14:00.001-07:00

After going through the comments on the Alpha Review, I've noted a few areas I could improve on, such as going into more detail on my project context as well as overall progress. The comments were helpful in giving me advice for resources as well as directions to consider for the project. Next I'll address some of the major points in the comments.

Will the final project be procedural generation of a city or just buildings?
This is something I've been thinking about since a few weeks ago. There are two parts to procedurally generating a city: the generation of the building itself, and then the creation of a city by populating city blocks with buildings. While I originally intended to focus on generating the building model, it's something that has been explored many times already, and I think it'd be more interesting to explore different ways the user can interface with Maya to generate a city. Norm suggested I could have my script import a color-map from the user to determine which types of buildings should be generated in each region of a city. I feel this is a good point to start off on once I finish implementing the functionality to generate a basic building.

How is this different from CityEngine and how does the user benefit from using a plug-in in Maya?
At the moment, most of CityEngine's building generation is done through user-created files. I think it'd be neat if my script can offer a more visual approach like the one I mentioned earlier. Right now I have a couple ideas I'm planning on trying out next week. Until then, thanks for looking!

Alpha Review

2011-10-30T20:03:00.000-07:00

Jump to see my current code

//==================TO DO==============================//
/*
-user input check for empty footprint submission
polyUnite, group
add user config ledge
make building hollow
implement building scaling (generate more floors)
    -add multiple types

-create selection for floors+ledge via groups
-attach jobScript for scaleY
-when user scalesY, take floor height and add/subtract floors if necessary
-update the text inside numFloors
-move -r 0 -4.866739 0 test.scalePivot test.rotatePivot ; //moves pivot
-add base and roof

-pickWalk -d up; //to access an object's group
-for ( $i=0; $i < size($conds); $i++ ){

//==================TO FIX==============================//
-how to select objects in a group???? (TO FIX)
-How to manipulate Maya scale function
-update GUI when ledge changes
-add a curve as a tool
-FIX SCALING BUG



*/

//================== CREATE GUI ==============================//

if(`window -exists myUI`){
    deleteUI myUI; //deletes duplicate UI if it exists
    windowPref -remove myUI;
}

window -title "CIS 497: SmallTown" myUI;

tabLayout myTab;
    //BULDING CREATER TAB
    columnLayout -adjustableColumn 1 columnCreation;
        frameLayout -label "Building Attributes";
            columnLayout;
                textFieldGrp -l "Building Name:" -tx "DEFAULT_BLDG" Building_Name;
                textFieldButtonGrp -l "Foot Print:" -tx "DEFAULT_SQUARE_PLANE" -bl "Set" -buttonCommand "getSelectedFootPrint" FootPrint_Name;
            setParent ..;
        setParent ..;
        frameLayout -label "Floor Attributes" -collapsable true;
            columnLayout;
                intFieldGrp -l "# of Floors:" -v1 3 NumFloors;
                floatFieldGrp -l "Floor Height:" -v1 3 FloorHeight;
                floatFieldGrp -l "Ledge Height:" -v1 1 LedgeHeight;
                floatFieldGrp -l "Ledge Protrusion:" -v1 0.2 ledgeProtrusion;
                //ledge depth
            setParent ..;
        setParent ..;
        frameLayout -label "Window Attributes" -collapsable true;
            columnLayout;
                floatFieldGrp -l "Height Ratio:" -v1 0.8 WindowHeightRatio;
                floatFieldGrp -l "Width Ratio:" -v1 0.5 WindowWidthRatio;
            setParent ..;
        setParent ..;
        button -l "Create" -command "createBuilding";
    setParent ..;


    //COMPONENT SELECTION TAB
    columnLayout -rowSpacing 0 -adjustableColumn 1 columnSelection;
        text -label "\nClick on component type to filter them from the current selection \n";
        button -label "Floors" -command "selectComponent(\"floor\")" floorSelection;
        button -label "Ledges" -command "selectComponent(\"ledge\")" ledgeSelection;
        button -label "Windows" -command "selectComponent(\"window\")" windowSelection;
        button -label "ALL" -command "select -all" allSelection;
    setParent ..;

//Edit tab attributes
tabLayout -edit
    -tabLabel columnCreation "Creation"
    -tabLabel columnSelection "Selection"
myTab;



showWindow myUI; // displays the window

//=================== BUILDING CREATION ============================//

//Main method that generates the building geometry
global proc createBuilding(){
    createFootPrint();
    createFloors();

    //put the building in a group
    select -all;
    string $buildingGroup = `group -name building`;

    //move building pivot
    select -r building.scalePivot;
    move -y 0;
    select -r building;

    //gets the children within the group
    /*
    string $geoNodes[] = `listRelatives -children -path $buildingGroup`;
    for($n = 0; $n < size($geoNodes); $n++){
        select -add $geoNodes[$n];
        print ($geoNodes[$n] + "\n");
    }
    */






    scriptJob -attributeChange "building.sy" "checkY";

    //delete footprint after everything's been created?
    //polyUnite to unite everything?
}

//creates the floors according to user specification
global proc createFloors(){
    string $footprintName = `textFieldButtonGrp -q -tx FootPrint_Name`;
    int $numFloors = `intFieldGrp -q -v1 NumFloors`;
    float $floorHeight =`floatFieldGrp -q -v1 FloorHeight`;
    float $ledgeHeight = `floatFieldGrp -q -v1 LedgeHeight`;
    float $currentHeight = 0.0;

    int $i;
    for($i=0; $i<$numFloors; $i++){
        createFloor($i, $footprintName, $currentHeight, $floorHeight, $ledgeHeight);
        $currentHeight += ($floorHeight + $ledgeHeight);
    }
}

//creates a single floor starting from the specified current height
global proc createFloor(int $numFloor, string $footprint, float $startHeight, float $floorHeight, float $ledgeHeight){
    string $tempFloorName = "floor" + $numFloor;
    string $tempFloor[] = `duplicate -name $tempFloorName $footprint`;
    select -replace $tempFloor[0];
    move -relative 0 $startHeight 0;
    ConvertSelectionToFaces;
    polyExtrudeFacet -kft true -ltz $floorHeight;
    print("created: " + $tempFloorName + "\n");

    //create the ledge that goes above a floor (for now)
    float $ledgeProtrusion = `floatFieldGrp -q -v1 ledgeProtrusion` + 1.0;
    string $ledgeName = "ledge" + $numFloor;
    string $tempFloor[] = `duplicate -name $ledgeName $footprint`;
    select -replace $tempFloor[0];
    float $ledgeTrans = $startHeight+$floorHeight;
    move -relative 0 $ledgeTrans 0;
    scale -relative $ledgeProtrusion $ledgeProtrusion $ledgeProtrusion; //user config later
    ConvertSelectionToFaces;
    polyExtrudeFacet -kft true -ltz $ledgeHeight;
    print("created: " + $ledgeName + "\n");

    //group the floor and ledge
    select -d;
    select $tempFloorName;
    select -add $ledgeName;
    string $levelName = "level" + $numFloor;
    //group -name $levelName;
    //print("grouped: " + $levelName + "\n");


    //scriptJob such that selecting a floor or ledge will select the group level it belongs to
    //scriptJob -ct "SomethingSelected" "pickWalk -d up";
}

//sets text for building footprint textbox. Assumes user only selected one object
global proc getSelectedFootPrint(){
    $selection = `ls -sl`;
    textFieldButtonGrp -edit -text $selection FootPrint_Name;
}

//establishes footprint for building
global proc createFootPrint(){
    $footprintName = `textFieldButtonGrp -q -tx FootPrint_Name`;
    if($footprintName == "DEFAULT_SQUARE_PLANE"){
        string $createdFootPrint[] = `polyPlane -ch on -o on -w 10 -h 10 -cuv 2 -name "DEFAULT_SQUARE_PLANE"`;
        select -r $createdFootPrint[0];
    }
    /*else{
        select -r $footprintName;
    }*/
    print("createFootPrint complete!!\n");
}

//=================== BUILDING SELECTION ============================//

//filters out all ledges from a user's selection
global proc selectComponent(string $name){
    string $selection[] = `ls -sl`;

    for( $obj in $selection){
        if( `substring $obj 1 5` != $name){
            select -d $obj;
        }
    }
}

//=================== BUILDING EDITING ============================//
global proc checkY(){
    //print("CHECK Y\n");
    int $numFloors = `intFieldGrp -q -v1 NumFloors`;
    float $floorHeight =`floatFieldGrp -q -v1 FloorHeight`;
    float $ledgeHeight = `floatFieldGrp -q -v1 LedgeHeight`;
    string $footprintName = `textFieldButtonGrp -q -tx FootPrint_Name`;

    float $sy = `getAttr building.sy`;
    float $currentHeight = 0.0;
    for($i=0; $i<$numFloors; $i++){
        $currentHeight += ($floorHeight + $ledgeHeight);
    }
    float $newHeight = $sy * $currentHeight;



    print("S.Y IS: " + $sy + " CURRENT HEIGHT IS: " + $currentHeight + " NEW HEIGHT IS: " + $newHeight + "\n");

    print("CHECK\n");
    //createFloor($numFloors, $footprintName, $newHeight, $floorHeight, $ledgeHeight);
    //add floor to building group


    //first delete everything
    for($i=0; $i<$numFloors; $i++){
        $delFloor = "floor" + $i;
        $delLedge = "ledge" + $i;
        delete $delFloor;
        delete $delLedge;
    }


    //then recreate everything again with the recalculated values
    $numFloors = $newHeight / ($floorHeight + $ledgeHeight); //first get the closest number of floors as an int
    $floorHeight = $newHeight / $numFloors - $ledgeHeight; //then adjust the floorHeight such that the new Height is exactly what the user specified
    $currentHeight = 0;

    for($i=0; $i<$numFloors; $i++){
        createFloor($i, $footprintName, $currentHeight, $floorHeight, $ledgeHeight);
        $currentHeight += ($floorHeight + $ledgeHeight);
    }

    //replace the values in the GUI
    intFieldGrp -edit -v1 $numFloors NumFloors;
    floatFieldGrp -edit -v1 $floorHeight FloorHeight;

    refresh;



}

//===================OLD STUFF============================//

// Retrieves all values from the GUI and assigns them to variables
// NOT CALLED, FOR REFERENCE ONLY
global proc retrieveGUIValues(){
    //building attributes
    $buildingName = `textFieldGrp -q -tx Building_Name`;
    $footprintName = `textFieldButtonGrp -q -tx FootPrint_Name`;

    //floor attributes
    $numFloors = `intFieldGrp -q -v1 NumFloors`;
    $floorHeight =`floatFieldGrp -q -v1 FloorHeight`;
    $ledgeHeight = `floatFieldGrp -q -v1 LedgeHeight`;

    //window attributes
    $windowHeightRatio = `floatFieldGrp -q -v1 WindowHeightRatio`;
    $windowWidthRatio = `floatFieldGrp -q -v1 WindowWidthRatio`;

    //check
    print ("creating building named " + $buildingName + " with " + $numFloors + " floors! LOL Just Kidding! \n");

}

/*
global proc makeSimpleBuilding(int $height){
   polyPlane -name myPlane -sw 3 -sh 3;
   ConvertSelectionToFaces;
   polyExtrudeFacet -kft true -ltz $height;
}

global proc printText(){
    print "\n You have clicked me!";
}

window;
columnLayout;
    button -label "button yay" -command "printText()";
showWindow;

window;
columnLayout -adjustableColumn true;
textField -text "Enter building height" -enterCommand "makeSimpleBuilding(3)";
showWindow;
*/

Shaping Up the GUI

2011-10-20T01:02:00.000-07:00

TO DO:
Have a GUI that creates a very basic building according to user specifications [3/6]

IN PROCESS:
Fine tune details for implementation [1/6]

COMPLETED:
Set up SVN [0/1]
Research dis/advantages of using Python vs. C++ API's for Maya [0/3]
Experiment with MEL UI creation [0/3]
Read about Maya Nodes[0/5]
Read about Maya C++ API, MEL Scripting [0/10]
Build basic plug-in for Maya in MEL[0/4]
Set up framework [0/5]

While looking through tutorials on making MEL GUI's, I came across this page that introduced groups of controls, such as intFieldGroup. Previously I had been trying to create my GUI with individual text labels, fields, and buttons, but this simplified the process a lot. Right now I have a GUI with frame and column layouts. I also figured out how to extract the user input as a button command, so my next step is to finish creating the geometry from these inputs.

The name is a placeholder for now...

For now, I plan on limiting the generation of the building to just user interaction with the GUI. Once I complete all the functionality listed in the current GUI, I'll start incorporating dynamic resizing. From this tutorial, the process seems like it will have to incorporate scriptJobs. I haven't looked very closely at this section yet, but plan on reading more about it in the future.

A small problem I hadn't foreseen is global variables in MEL. I initially had a global proc that extracts all the user inputs from the GUI and dumps them into variables, since it's easier to keep track of what's what (see below):

// Retrieves all values from the GUI and assigns them to variables
global proc retrieveGUIValues(){
    //building attributes
    $buildingName = `textFieldGrp -q -tx Building_Name`;
    $footprintName = `textFieldButtonGrp -q -tx FootPrint_Name`;

    //floor attributes
    $numFloors = `intFieldGrp -q -v1 NumFloors`;
    $floorHeight =`floatFieldGrp -q -v1 FloorHeight`;
    $ledgeHeight = `floatFieldGrp -q -v1 LedgeHeight`;

    //window attributes
    $windowHeightRatio = `floatFieldGrp -q -v1 WindowHeightRatio`;
    $windowWidthRatio = `floatFieldGrp -q -v1 WindowWidthRatio`;

    //check
    print ("creating building named " + $buildingName + " with " + $numFloors + " floors! LOL Just Kidding! \n");
}

However, I soon realized that these variables are out of the scope of all the other procs, and I need to specify them as global to rectify this. Using global variables requires an additional step of declaring it within each proc, which in the end isn't much cleaner than just re-extracting the user input whenever I need it, so off to the recycle bin this goes.

Another Update

2011-10-09T20:29:00.000-07:00

TO DO:
Build basic plug-in for Maya in MEL[1/4]

IN PROCESS:
Fine tune details for implementation [2/6]
Set up framework [2/5]

COMPLETED:
Set up SVN [0/1]
Research dis/advantages of using Python vs. C++ API's for Maya [0/3]
Experiment with MEL UI creation [0/3]
Read about Maya Nodes[0/5]
Read about Maya C++ API, MEL Scripting [0/10]

Kind of a short update for this week. I've finished reading the first 3 chapters of Complete Maya Programming, which covers the Maya Dependency Graph and MEL scripting. Right now I'm trying to create a simple GUI that lets users extrude the body of a building from a custom "footprint". At the moment I'm having some trouble with executing commands when the user interacts with the GUI, but hopefully that will be fixed shortly. I will have another update when that's done.

Thanks for looking and have a great fall break!

Starting Out, Logistics, and More

2011-09-29T16:10:00.000-07:00

When I was interning at EA over the summer, my team adopted Scrum, which is an agile process for software development mostly suited for projects with rapidly changing requirements. Though my senior design doesn't fit that description exactly (though the "rapidly changing requirements" might come into play later when I start figuring what's possible and what isn't), the process of labeling each task and estimating a "burn down" time was immensely helpful for keeping me on track at work. Thus, a logical thing to do now is to apply the most practical aspects of Scrum to this project. So, without further ado, I present my makeshift text-based scrum board, along with tasks from my initial game plan and some for next week:

Note: Numbers in [ ] are estimated time left / projected hours needed

TO DO:
Build basic plug-in for Maya in MEL[4/4]
Read about Maya Nodes[5/5]

IN PROCESS:
Read about Maya C++ API, MEL Scripting [8/10]
Fine tune details for implementation [5/6]
Set up framework [4/5]
Experiment with MEL UI creation [2/3]

COMPLETED:
Set up SVN [0/1]
Research dis/advantages of using Python vs. C++ API's for Maya [0/3]

I spent part of this week reading about the two main API's available for writing tools for Maya, namely Python and C++. From what I gathered online, most users agreed that python was an ideal entry point for learning to program for Maya because of its intuitive syntax. However, it's not as well documented online as its C++ counterpart. After talking with Joe and some friends with more expertise in the area, it seemed that C++ is more ideal for this project, since it offers more control and functionality (ie. creating custom nodes in Maya). I also found an article on interfacing between the two API's if the need ever arises.

I've also started to explore creating MEL user interfaces. I'm working through the examples on this site right now, so far everything's been easy to follow, and it's encouraging to have even a little bit of visual feedback.

Test window generated from the tutorial

For the next week, I'm planning on reading more about the Maya Dependency Graph and creating nodes.

Finally, here's the preliminary system diagram for my building generator:

I'm planning on emailing a few people this week to make sure that this is a reasonable approach, so the chart is subject to change depending on how the feedback turns out.

Also, Gliffy (the chart generator) is pretty amazing (thanks Marley!)

An Updated Approach

2011-09-23T01:08:00.000-07:00

This week I rewrote some parts of my original design document, and I've up with a more detailed approach for my project. After talking to people who have implemented similar projects, the general advice I gathered was that it was best to ensure basic functionality first, before trying to implement all the details of a paper.

My major goal last week was to read through all the papers and find one that is most relative to my project. Vijay, who worked on the Building Building Builder project from a previous year, recommended Interactive Visual Editing of Grammars for Procedural Architecture, so I've decided to focus on this paper after I've created the tool with some basic functionalities.

As for the work flow, my plan for next week is to finish reading about scripting for and have a basic plug-in running that can create a cube and apply basic transformations (namely scale and rotation). The next step after that would be to add additional faces and edges onto the cube.

I'm really looking forward to next week and having a skeleton up and running. Thoughts and suggestions are much appreciated!

Game Plan

2011-09-14T23:01:00.000-07:00

Things to check off for next week:

Finish background reading
Read about Maya C++ API, MEL Scripting
Iron out details for implementation
Start setting up the framework
Set up SVN

And So It Begins...

2011-09-14T22:23:00.000-07:00

Procedural Generation of Urban Environments: the Abstract

With the advent of modern movies and video games, the demand for visually stimulating environments comprised of unique components has been ever increasing. Traditionally, the problem has been solved by simply creating more assets. However, given the time and effort necessary to create 3D models, a producer risks spending a lot of resources on what is ultimately a small part of the final product. Consequently, this solution becomes much less feasible.

An alternative to manually creating individual components is procedural generation. The result is a large number of variable 3D assets generated in relatively a short amount of time compared to the traditional method. This project will focus on the procedural generation of buildings in an urban environment. Users will be able to create procedurally generated buildings via a Maya authoring tool plug-in. The ultimate goal is for users to create urban environments without the need to model each structure individually.

Some Updates

2010-08-04T14:06:00.000-07:00

I talked to Ben about randomizing lots, and he introduced me to stochastic rules in CityEngine, which creates variation in lots using randomness. One example (take from the CE help page) would look like:

Lot -->
30% : Lot("residential")
20% : Lot("retail")
else : Lot("industrial")

Currently I'm using another method to randomly generate structures on a lot. It's "get" function that returns different file paths at different probabilities. See the following:

getBuilding =
20%: "assets/shack1.obj"
30%: "assets/shack2.obj"
20%: "assets/shack3.obj"
else: "assets/shack4.obj"

For now I find this easier than the previous method since it doesn't require me to define a new symbol for each possibility. I'll probably use it when I need a lot to develop into different types of procedurally generated buildings (Right now a majority of them are OBJ's...I cheated a little).

I also inserted vegetation into the city. It's funny how much of a differences trees make.

Trees added without wireframes (since they tend to make the leaf-clusters look black)

Now with wireframes (just for comparison)

City view. The shadows really slowed the computer down. They look nice, though.

Also met with Joe, Norm, and Ben today. For now I'll be working mostly under Ben. For his city he wanted procedurally generated buildings (as opposed to OBJ's), since that method would allow us to identify doors on a building. We will be starting with roughly 5 types of buildings: Home, School, Inns, Food/Convenience Stores, and Restaurants. A high level of detail isn't required this time, so most of the architecture will be very basic.

Also working on the slides at the moment. Since I'm posting here already, I might as well include the pictures I'll show on the slides.

Street network generated in CityEngine via Open Street Map file (of Basra)

Lots generated from the street network

Sidewalks and roads are added.

By golly do I love blogger's editor. I feel like I'm being spoiled.

Back to work

2010-08-02T15:00:00.000-07:00

SAAST just ended, so I'm back at the SIG Lab. Decided today would be a good day to start keeping track of what I do (should have really started earlier, oh well)

Recap so far:
Created a scalable shack that generates additional garage doors at different positions depending on how wide the shack is.

Maya model imported into CityEngine:

Planning out the city:
One of the problems I've been thinking about was how to specify which lot contained what building. One of the potential ideas that came up was to create a variable that generated a building number randomly, and grow the lot from that. Something like:

//ATTRIBUTES//
attr building_type = rand(1,10) //we have 10 building styles here

//RULES//
Lot -->
case building_type == 1: Shack1
case building_type == 2: Shack2
...
else: Generic_building

Unfortunately, nothing happened when I tried running the above code. The next idea I tried was to filter the type of structure generated by the scopes of the lot sizes. Currently, if the x-scope and z-scope differ no more than 1, then a shack-structure will be created from the Lot. If either scope is smaller than 20, then a generic building will be created from that Lot. Although this system isn't very sophisticated, it does do the job of partitioning different lots for different structures. More changes may be implemented in the future.

Another Update

2010-05-01T15:19:00.000-07:00

-Just figured out how to convert .csv files into .dbf format via ArcCatalogue

Python Script I have so far:
# Most of it referenced from this tutorial
# There are some functions in the tutorial that returned an error when I tried to run it. This might be a version issue.

import sys, string, os, arcgisscripting

gp = arcgisscripting.create(9.3)

gp.Overwriteoutput = 1

#Specify the location for the new shapefile.

#gp.CreateFeatureclass("C:/Users/Alice/Desktop/Testing", "test_line.shp", "POLYLINE")

#Define Coordinate System

gp.workspace = "C:/Users/Alice/Desktop/Testing"

gp.toolbox = "management"

coordsys = "Coordinate Systems/Geographic Coordinate Systems/World/WGS 1984.prj"

gp.defineprojection("test_line.shp", coordsys)

#Open a cursor to insert rows into the shapefile.

cur = gp.InsertCursor("C:/Users/Alice/Desktop/Testing/test_line.shp")

#Create an Array and Point object.

lineArray = gp.CreateObject("Array")

pnt = gp.CreateObject("Point")

#Open a cursor on the table of XY coordinates to read from.

rows = gp.SearchCursor("C:/Users/Alice/Desktop/Testing/pythonTest.dbf")

#Reset the cursor to the top.

row = rows.Next()

#Loop through each record in the XY table..

while row:

#Set the X and Y coordinates for origin vertex.

pnt.x = row.GetValue("Origin_x")

pnt.y = row.GetValue("Origin_y")

#Insert it into the line array

lineArray.add(pnt)

#Set the X and Y coordinates for destination vertex

pnt.x = row.GetValue("dest_x")

pnt.y = row.GetValue("dest_y")

#Insert it into the line array

lineArray.add(pnt)

#Go to next row in table.

row = rows.Next()

#Insert the new poly into the feature class.

feat = cur.NewRow()

feat.shape = lineArray

cur.InsertRow(feat)

lineArray.RemoveAll()

del cur, row, rows

Update May 1st

2010-05-01T11:33:00.000-07:00

Right now the goal is to create a python script that plots the location on arcMap when given a longitude and latitude.

4/13 Update

2010-04-13T16:19:00.000-07:00

I visited Ken today to help me with ArcGIS. Below are my notes for setting up a route between 2 points using ArcMap.

-Download files from PASDA->open in ArcCatalogue->drag the file into 'layers' in ArcMap

-Use the select tool to select part of the map (the whole map will take too long to process)

-In the layer window->selection tab:
Right click
Create layer from selected features
Clear selected features(this is a button on the right toolbar)
To save this, right-click -> data -> export data

-Create address Locator
A.L.Style: US Streets w/ zone
Ref. Data: teststreet
Role: Primary table ->press OK

-Geocode Addresses
Input table->we need to make one
New excel file: 2 columns, address + zip. Enter 2 rows, arbitrary values
Save as CSV (we called it adds.csv)
*Note: don't share data files between programs. ArcGIS doesn't like that
Refresh ArcCatalogue (right click)
Drag adds file to layers (under source tab)
Right click->open
Back to geocode address->input table = adds
Input Address Locator the one we made -> has 2 points from the 2 rows in adds.
Use the 'i' tool to identify

Note: you can use Tools->geocoding->rematch addresses if adds are out of date

Network Analyst
Toolbar(view->status bar->networkanalyst)
To turn on: tools->extensions->check the box next to 'network analyst'

For more info: click Help->network analyst->workflow description

In catalog: street test-> new network dataset
Impedance = length
Click OK->creates a streetstest_ND file
Move the 2 ND files from catalog to streetfile layer
New route->route->load locations->add ouradds
Finally click the solve button

Just plotting down 2 points and creating a route between them took over 40 minutes. This was without python scripting, or moving the dots at all.

Screenshot:

Progress Report 4/12

2010-04-11T21:38:00.000-07:00

-Received 2 documents from Ken about Agent Analyst. I have a pretty clear idea on what Agent Analyst does now, it's just the implementation part that I'm still a bit lost on. The tutorials I've worked on give a basic sense of how to create an agent, but I haven't found any that would help my figure out how to create agents that visibly move across a map. These are the ones I've been working through. The Schelling GIS tutorial seems close to what I am looking for, since it involves agents on a map, but they aren't displayed individually, and the tutorial provides a pre-made file to load rather than guide the user in creating the agents and their movements. So far I've only found 3 tutorials---it seems that support for AgentAnalyst is quite limited, which is a bit frustrating.

I was able to download a world street file from the esri website (here), so it seems that PASDA will not be needed for now.

If Agent Analyst does not work, I've compiled some other programs to consider:

1. Attempt to place object on a layer in ArcMap, and manipulate it along a street using Python script. I've emailed Ken about the probability of this alternative. Right now I'm waiting on a reply.

2. I found a version of Repast that integrates with eclipse (Repast Symphony). It seems like there is a lot more support for it than Agent Analyst. I'm already looking through tutorials. This is probably the best alternative if the above does not work.

4/9 Progress Report

2010-04-09T08:18:00.000-07:00

-Got Agent Analyst/Repast to work with ArcMap by using the Legacy version.
-Worked through tutorials to familiarize with the program
-Currently I got Agent Analyst to run within ArcMap and modify its map contents (see below)

Simple vector model of Chicago in Schelling tutorial by Arika Ligmann-Zielinska, Ph.D. Associate, San Diego State University

-It is possible to create agents using RepastPy, but making them display on the map is still in question (most likely possible though)

2010-04-07T19:45:00.001-07:00

selfnote: http://www.institute.redlands.edu/agentanalyst/tutorials.aspx

4/2 Meeting Recap

2010-04-04T20:00:00.000-07:00

-Simulation will be one which people exit building during a fire drill.
-Blockades will be place along routes in order to force agents to navigate detours.
-Possibility of redefining my part of the project if Python scripting for ArcGIS doesn't work out

Some updates:

-Emailed Ken about executable jar file error for Agent Analyst/Repast. Seems like
it is indeed an incompatibility issue. He might be able to find version 9.2 for ArcGIS (which should run with Repast/AA)

-Links to check out:
http://repast.sourceforge.net/
http://forums.esri.com/Thread.asp?c=93&f=983&t=288747

Happy Easter!!

Progress Report 4/2

2010-03-31T18:40:00.000-07:00

-Installed PythonWin (along with python 2.6.5)

-Installed Repast 3/ Agent Analyst. There are still a few problems with it though--the jar executable won't run, and the batch file needed to add a toolbox into arcMap (agent_analyst.bat) generates a 'path not found' error. Not sure if this is due to installation issues, or incompatibility with the our version of ArcGIS (Most current version for Repast/AA is 9.2, we're running version 9.3)

Notes to self:
-So right now I have PythonWin running, and it is able to import arcgisscripting. I tried creating a geoprocessing object, gp = arcgisscripting.create(9.2), which works fine as well. Now I just need to figure out how to link these PythonWin and ArcMap together (shouldn't be hard...), and demo data to practice with.

Helpful Links:

Course-worth's of material:
http://www.gis.usu.edu/~jlowry/python/

http://blogs.esri.com/Support/blogs/esritrainingmatters/archive/2009/09/10/want-to-create-python-scripts-try-the-f-c-p-m-t-method.aspx

-Python ArcObjects
http://www.pierssen.com/arcgis/misc.htm
http://www.pierssen.com/arcgis/upload/misc/python_arcobjects.pdf

-Agent Analyst
http://www.institute.redlands.edu/AgentAnalyst/
Latest version of this supports ArcGIS 9.2, we have 9.3 so there might be compatibility issues.

-Repast
http://www.institute.redlands.edu/AgentAnalyst/repast.aspx

-PythonWin (for scripting in ArcGIS)
Download: http://sourceforge.net/projects/pywin32/
"Getting Started with Writing Geoprocessing Scripts"
"Installing PythonWin"

-Python 2.6.5
Download: http://www.python.org/download/releases/2.6.5/
Needed for PythonWin

3/26 Meeting Recap

2010-03-31T17:50:00.000-07:00

-For arcGIS in javascript, fine a file that stores information such as street numbers. They are generally called LTADD, LFADD (can be found on the PASDA website; spatial data info)

-Look into ArcMap Network Analyst
-Look into ArcGIS Repast Agent Analyst

-Pythonwin from sourceforge( for arcGIS)

-Find icon on top of little red hammer ->tool utilities ->create script
look for help menu in arcMap for help with arcpy (Python API for arcGIS)

-ksteif@sp2.upenn.edu (email for help)

Progress Report 3/26

2010-03-26T00:14:00.000-07:00

So it seems like it is possible to generate routes in the ArgGIS javascript API as well as locate points on the map based on an address input. The API links are below:

Routing overview
RouteTask
Working with RouteTask
Locator

Some difficulties:
-It's difficult to determine what type of map to import due to the variety of maps available and the fact that they can only be viewed in ArcGlobe.
(http://server.arcgisonline.com/ArcGIS/rest/services)

-Still trying to figure out the syntax for RouteTask. (Will most likely be working on this next week)

Locator for ArcGIS:
http://resources.esri.com/arcgisserver/apis/javascript/arcgis/index.cfm?fa=codeGalleryDetails&scriptID=16821

3/19 Meeting Recap

2010-03-25T20:46:00.000-07:00

-Try to connect the dots to actual geographical information on the map.
-See if additional data can be added to a map (ie. sidewalk)
-Check if ArcGIS has a route planner.

3/5 Progress Report

2010-03-04T23:47:00.000-08:00

Figured out how to animate the dot using a timer. Also, instead using a for-loop, I used setInterval:

function animate(){
var pt = oldLoc, i = 0, timer; // no global variables declared...

timer = setInterval(function () {
pt.y += 20;
pt.x += 20;
graphic.setGeometry(pt);
graphic.show();
//dojo.byId("info").innerHTML += "testingcheck";

if (i >= 1000) { // stop condition
clearInterval(timer);
}

i++;
}, 5);
}

And Happy Spring Break!

2/25 Update and Meeting Recap

2010-02-26T20:32:00.000-08:00

Progress Report:
*Since ThinkMap is deeply integrated into GCAT, it would be extremely difficult to replace it with FreeMind. Currently we're waiting on a 30-day trial version of ThinkMap.

*ArcMap can only render animations over the entire map. ArcScene can animate object layers along a set path (seen here) but it requires environmental data which can be difficult to generate.

*Using the ArcGIS Javascript API seems to be the best solution now. The user is able to generate markers on a map and move it. Animation still needs some work.

*The PowerPoint presentation can be downloaded here.
*The dragPoint file can be downloaded here.

To Do:
*Figure out how to animate the markers using a timer in javascript.

2/19/2010 Meeting Recap

2010-02-22T20:26:00.000-08:00

Notes:
*Since we're still in the process of getting a license of ThinkMap, Norm suggested looking into FreeMind, which is an entity-relation map and happens to be free.

*My idea of using coordinates on the ArcMap map display to display data didn't go through--Zooming in would cause the image to pixelate/degenerate, which is why we need an actual object/objects on the map.

*Random tidbits: Lockheed Martin has developed a software called CultureSim that we might use in place of GCAT should it prove to be insufficient.

To-Do:
*Figure out if ThinkMap can be replaced by FreeMind
*Which databases have we been given to pull all the components of GCAT together.
*Find out if it is possible to animate marker objects in ArcMap.

Edit/Update: Joe heard back from ThinkMap. Seems like they're not willing to give us a free license so that's most likely a no-go.

2/19/10 Progress Report

2010-02-19T10:06:00.000-08:00

*Installed MySQL. Next step would be to look up tutorials/become familiar with the program.

*From the documentation Norm sent me it seems like GCAT needs an additional software, Thinkmap, to fuction. I emailed them about obtaining a limited license and Joe will be taking care of the rest of the process.

*It seems like ArcMap can support animation from this tutorial I found. From the introduction:

Animations can be created in ArcMap™, ArcScene™ or ArcGlobe™. With an animation, you can visualize changes to the properties of objects (such as layers, the camera, or the map extent). By altering layer properties, such as the time stamp that is displayed or layer visibility and transparency, you can create interesting animations that can be used to analyze data through time or to view information in various layers. By altering the extent (ArcMap) or the camera position (ArcScene or ArcGlobe), you can create an animation that moves around a map, scene or globe. Examples of applications that would benefit from being viewed as an animation include:

• The occurrence of events through time, such as hurricanes or precipitation, the spread of a disease, or population change
• The navigation of an object (such as a car) through a landscape (example here)
• A visualization of information in multiple layers by applying transparency

The second bullet seems close to what we're looking for, although I'm not sure what the effects would be if we had multiple objects (possible lag?). Also, judging from the videos, it seems that ArcMap is more suited for animating a spread rather than single points of data. If GCAT doesn't work, this may be a viable option.

More references:
Animation in ArcMap tutorial index
Animating data through time
Sample animation videos

2/12/10 Meeting Notes

2010-02-16T19:55:00.000-08:00

*Try to see if it's possible to move dots from one latitude/longitude to another in GCAT using a simple or loop

*See if trail can be updated/erased. Some ideas for erasure was to put a street-colored on the old dot and masking it out, since redrawing the whole map would be expensive

*Next meeting will be at 2pm