Work completed 07/28 - 08/02

Incorporated wigwam grid display code into drawing window of WW based on Core application framework.  Grid now displays correctly in drawing pane as follows:

Currently working on adding logic for adding arc objects.  hope to be done with this over next couple days.

Work completed 07/21 - 07/27

Set up a new Wigwam project based on the pCSDT application framework.  This involves the following:

1.  Set up new project called WW with proper references to the Core library that contains the code for pCSDT.
2.  Define a new class called WigwamEngine that extends PEngineOgl (from core) which detects the new classes representing objects to be drawn, Arc and Torus.
3.  Define a new class called WigwamGui that extends PGuiOgl (from core) which creates the gui environment and holds a reference to the WigwamEngine object.

Currently working on overriding the Draw() method of PEngineOgl that will contain logic for drawing the grid Wigwam application.  This was discussed in yesterday's meeting.

Work completed 07/14 - 07/20

Incorporated functionality for producing semi-circular arcs (an enhancement to the existing functionality that produces parabolic arcs in the wigwam applet).  The idea is to utilize this functionality for producing bucky balls. However, coincident with this, embarking on an effort to port the wigwam applet to the pCSDT application framework and to create bucky ball functionality within that environment, as well.

Met with Jed Williams on campus on Monday, 07/18.  Discussed his application, the break dancer applet and its design, given it is built within the pCSDT application framework.  The design is based around 3 major ideas:  first, there is a gui class that extends a framework gui class that establishes the container frame and initializes gui settings; second there is an engine that provides the functionality for objects to be managed and programmed within the pCSDT framework, and third, there are the application-specific objects themselves to be managed within the environment (e.g., the human class and the torus class are both objects of this type within the break dancer).

Next steps include the following:

1.  Port the wigwam applet into the pCSDT application framework.  This involves recreating the grid display, arc production, and arc removal within the context of the pCSDT platform.

2.  Build the functionality for creating tori in the pCSDT application framework in order to support building bucky balls.  Some questions around this issue exist:  Should this functionality be built using the same grid display backdrop that exists for the wigwams?  Or should it be totally separate?  This begs the question of what the students are supposed to be doing with the bucky balls - does the software provide a model for some real-life production of a bucky ball much like the wigwam applet provides coordinates for creating model wigwams?  What aspects of the bucky ball functionality should be programmable?

3.  Make the wigwam functionality programmable.  Questions here include what aspects should be programmable?  One idea is to provide the user the ability to set a number of arcs and an angle between them and then the software automatically creates the defined number of arcs spaced according to the input angle.

Update 07/18/2011

Incorporated functionality to produce circular arcs in the wigwam applet (as opposed to parabolic arcs).  This update leverages current code for parabolic arcs, including transformations for 3d support, but replaces points approximating a parabolic arc with equations for points for a circular arc.  Also, incorporated detailed documentation explaining both the logic for creating points for parabolic arc and for circular arcs.

Next, need to incorporate buttons in gui for segregating creation of circular arcs (eventually to support bucky balls) from the original functionality for creating parabolic arcs (supporting wigwams).

Work completed 07/07 - 07/13

Working on leveraging existing code to create new circles within context of a separate project.  Having issues making the graphic (circle) appear on the screen.  This must be a setting within the JOGL environment that I'm missing.  Have been working on this, again, mostly trying to use existing code from Wigwam applet class (i.e., searching for any switches there that could do the trick).  Hope to have this resolved in next few days.

Work completed 06/23 - 06/29

Working on creating bucky ball functionality within  the wigwam applet.  This functionality is based on functionality for creating circles on the 3d graph display.  This required the following steps completed over the course of the week:

1.  review Bresenham's algorithm for selecting pixels to approximate circular arcs.  Using the following text as reference:  Computer Graphics for Java Programmers
2.  review concepts for creating 3d perspective (as opposed to 2d graphics).  Using same text as above as reference.
3.  review concepts for creating 3d perspective using jogl library.  Using the following text as reference:  Foundations of 3D Graphics Programming Using JOGL and Java 3D
4.  review wigwam code for creating arcs (specifically the drawArc function of the WigWam class).  This is where the meat of the arc point calculations are performed.

Looking to leverage this code to create circular arcs, then create circular arcs of different angles of rotation about the z axis.

Work completed 06/16 - 06/22

Began work on enhancement to Wigwam applet for making horizontal arcs, per the direction from the email below:


---------------------------- Original Message ----------------------------
Subject: RE: weekly update
From:    "Eglash, Ron" <eglash@rpi.edu>
Date:    Thu, June 16, 2011 10:24 pm
To:      johnsj3@cs.rpi.edu
--------------------------------------------------------------------------

Lets take this one step at a time. First step: allow "horizontal" arcs
so the kids can make the part of the wigwam that wraps around the
middle. Then we will worry about buckyballs.

Currently the applet only allows arcs that are "vertical". The user can
only rotate the arc around the Y axis. (Of course we don't mean just the
single Y axis at x=0, z=0. Rather we mean any line running parallel to
the Y axis.)

We need two more degrees of freedom:

1)    Such that the user can rotate the arc around the X axis (Of course
we don't mean just the single X axis at y=0, z=0. Rather we mean any
line running parallel to the X axis. And since they can rotate around Y,
that means it could even be parallel to the Z axis.).

2)    Such that the user can move the arc up higher or lower. We will
need to make sure the labels distinguish this from the parameter that
determine how tall the arc will be,

*****end email************************************

The approach is to leverage code for current functionality for making horizontal arcs.  Attempting to modify existing code to make it sufficiently generic to support both elements of functionality - making vertical arcs and horizontal arcs.  Once this is complete, will address the issue of being able to rotate the arc around the x-axis, hopefully, using code similar to that for rotating around the y-axis.  Finally, linear translation of the axis of axis will be modified/leveraged in the existing code base for supporting vertical translation of the axis for horizontal arcs.