|
/**********************************************************
Copyright (C) 2001 Daniel Selman
First distributed with the book "Java 3D Programming"
by Daniel Selman and published by Manning Publications.
http://manning.com/selman
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation, version 2.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
The license can be found on the WWW at:
http://www.fsf.org/copyleft/gpl.html
Or by writing to:
Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Authors can be contacted at:
Daniel Selman: daniel@selman.org
Lee Dixon: leedixon@email.com
If you make changes you think others would like, please
contact one of the authors or someone at the
www.j3d.org web site.
**************************************************************/
import java.applet.Applet;
import java.awt.Button;
import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import javax.media.j3d.Alpha;
import com.sun.j3d.utils.applet.MainFrame;
/**
* Draws a simple plot of a parameterized Java 3D Alpha Function to an AWT
* Window.
*/
public class AlphaTest extends Applet implements ActionListener {
/**
* default size of the window
*/
private static int m_kWidth = 400;
private static int m_kHeight = 400;
/**
* indexes into the UI components we create
*/
private static final int m_knTrigger = 0;
private static final int m_knPhaseDelay = 1;
private static final int m_knIncreasingAlpha = 2;
private static final int m_knIncreasingRamp = 3;
private static final int m_knAtOne = 4;
private static final int m_knDecreasingAlpha = 5;
private static final int m_knDecreasingRamp = 6;
private static final int m_knAtZero = 7;
private static final int m_knLoopCount = 8;
/**
* controls how smooth a plot curve we create
*/
private final static long m_kTimeStep = 10;
/**
* the Java 3D Alpha object we are parameterizing
*/
private Alpha m_Alpha = null;
/**
* a Vector of Edit UI components
*/
Vector m_EditFieldVector = null;
/**
* offsets and drawing information
*/
int m_nMaxHeight = 0;
int m_nMaxWidth = 0;
int m_nInsetX = 0;
int m_nInsetY = 0;
int m_nGraphMaxWidth = 0;
int m_nGraphMaxHeight = 0;
int m_nGraphInsetX = 0;
int m_nGraphInsetY = 0;
double m_ScaleX = 0;
/**
* CheckboxGroup for INCREASING/DECREASING PHASE enable
*/
private CheckboxGroup m_checkboxGrp;
/**
* Constructor
*/
public AlphaTest() {
m_Alpha = new Alpha(-1, Alpha.DECREASING_ENABLE
| Alpha.INCREASING_ENABLE, 1000, 1000, 5000, 1000, 1000, 10000,
2000, 4000);
buildUi();
}
/**
* Creates the UI components
*/
protected void buildUi() {
m_EditFieldVector = new Vector(10);
addField("Trigger Time", m_knTrigger);
addField("Phase Delay", m_knPhaseDelay);
addField("Increasing Alpha", m_knIncreasingAlpha);
addField("Increasing Ramp", m_knIncreasingRamp);
addField("At One", m_knAtOne);
addField("Decreasing Alpha", m_knDecreasingAlpha);
addField("Decreasing Ramp", m_knDecreasingRamp);
addField("At Zero", m_knAtZero);
addField("Loop Count", m_knLoopCount);
m_checkboxGrp = new CheckboxGroup();
add(new Checkbox("INCREASING_ENABLE", m_checkboxGrp, false));
add(new Checkbox("DECREASING_ENABLE", m_checkboxGrp, false));
add(new Checkbox("BOTH", m_checkboxGrp, true));
addButton("Update");
updateUi();
}
/**
* Handle events from the GUI components we created
*/
public void actionPerformed(ActionEvent event) {
if (event.getActionCommand().equals("Update") != false) {
updateAlpha();
repaint();
}
}
/**
* Replots the Alpha function based on the contents of the UI
*/
protected void updateAlpha() {
m_Alpha.setTriggerTime(Long.parseLong(getField(m_knTrigger).getText()));
m_Alpha.setPhaseDelayDuration(Long.parseLong(getField(m_knPhaseDelay)
.getText()));
m_Alpha.setIncreasingAlphaDuration(Long.parseLong(getField(
m_knIncreasingAlpha).getText()));
m_Alpha.setIncreasingAlphaRampDuration(Long.parseLong(getField(
m_knIncreasingRamp).getText()));
m_Alpha.setAlphaAtOneDuration(Long.parseLong(getField(m_knAtOne)
.getText()));
m_Alpha.setDecreasingAlphaDuration(Long.parseLong(getField(
m_knDecreasingAlpha).getText()));
m_Alpha.setDecreasingAlphaRampDuration(Long.parseLong(getField(
m_knDecreasingRamp).getText()));
m_Alpha.setAlphaAtZeroDuration(Long.parseLong(getField(m_knAtZero)
.getText()));
m_Alpha.setLoopCount(Integer
.parseInt(getField(m_knLoopCount).getText()));
Checkbox b = m_checkboxGrp.getSelectedCheckbox();
if (b.getLabel().equals("INCREASING_ENABLE")) {
m_Alpha.setMode(Alpha.INCREASING_ENABLE);
} else if (b.getLabel().equals("DECREASING_ENABLE")) {
m_Alpha.setMode(Alpha.DECREASING_ENABLE);
} else // "BOTH"
{
m_Alpha.setMode(Alpha.INCREASING_ENABLE | Alpha.DECREASING_ENABLE);
}
}
/**
* Updates the UI based on the Alpha function
*/
protected void updateUi() {
getField(m_knTrigger).setText(String.valueOf(m_Alpha.getTriggerTime()));
getField(m_knPhaseDelay).setText(
String.valueOf(m_Alpha.getPhaseDelayDuration()));
getField(m_knIncreasingAlpha).setText(
String.valueOf(m_Alpha.getIncreasingAlphaDuration()));
getField(m_knIncreasingRamp).setText(
String.valueOf(m_Alpha.getIncreasingAlphaRampDuration()));
getField(m_knAtOne).setText(
String.valueOf(m_Alpha.getAlphaAtOneDuration()));
getField(m_knDecreasingAlpha).setText(
String.valueOf(m_Alpha.getDecreasingAlphaDuration()));
getField(m_knDecreasingRamp).setText(
String.valueOf(m_Alpha.getDecreasingAlphaRampDuration()));
getField(m_knAtZero).setText(
String.valueOf(m_Alpha.getAlphaAtZeroDuration()));
getField(m_knLoopCount).setText(String.valueOf(m_Alpha.getLoopCount()));
}
/**
* Helper method to add a TextField to the UI
*/
protected void addField(final String szText, final int nIndex) {
Label label = new Label(szText);
TextField textField = new TextField(4);
m_EditFieldVector.add(nIndex, (Object) textField);
add(label);
add(textField);
}
/**
* Retrieves a TextField with a given index
*/
protected TextField getField(final int nIndex) {
return (TextField) m_EditFieldVector.get(nIndex);
}
/**
* Helper method to add a Button to the UI.
*/
protected void addButton(final String szText) {
Button button = new Button(szText);
button.addActionListener(this);
add(button);
}
/**
* Computes the drawing scales based on the Alpha function and the size of
* the Window.
*/
protected void computeDrawScale(long lMaxTime) {
m_nMaxHeight = (int) (getHeight() * 0.7);
m_nMaxWidth = (int) (getWidth() * 0.9);
m_nInsetX = (getWidth() - m_nMaxWidth) / 2;
m_nInsetY = (int) ((getHeight() - m_nMaxHeight) / 1.1);
m_nGraphMaxWidth = (int) (m_nMaxWidth * 0.80);
m_nGraphMaxHeight = (int) (m_nMaxHeight * 0.80);
m_nGraphInsetX = m_nInsetX + (m_nMaxWidth - m_nGraphMaxWidth) / 2;
m_nGraphInsetY = m_nInsetY + (m_nMaxHeight - m_nGraphMaxHeight) / 2;
m_ScaleX = ((double) m_nGraphMaxWidth) / ((double) lMaxTime);
}
/**
* Draws a rectangle into the display area for the plot.
*/
protected void drawAreaRect(Graphics g, int x, int y, int width, int height) {
g.drawRect(m_nInsetX + x, m_nInsetY + y, width, height);
}
/**
* Draws a String into the display area for the plot.
*/
protected void drawAreaString(Graphics g, int nLen, String szText,
double x, double y) {
if (nLen > 0 && szText.length() > nLen)
szText = szText.substring(0, nLen);
g.drawString(szText, (int) (m_nInsetX + x), (int) (m_nMaxHeight
+ m_nInsetY - y));
}
/**
* Draws a String into the graph area for the plot.
*/
protected void drawGraphString(Graphics g, int nLen, String szText,
double x, double y) {
if (nLen > 0 && szText.length() > nLen)
szText = szText.substring(0, nLen);
g.drawString(szText, (int) (m_nGraphInsetX + x), (int) (m_nGraphInsetY
+ m_nGraphMaxHeight - y));
}
/**
* Draws a Line into the graph area for the plot.
*/
protected void drawGraphLine(Graphics g, double x1, double y1, double x2,
double y2) {
g.drawLine((int) (m_nGraphInsetX + x1), (int) (m_nGraphInsetY
+ m_nGraphMaxHeight - y1), (int) (m_nGraphInsetX + x2),
(int) (m_nGraphInsetY + m_nGraphMaxHeight - y2));
}
/**
* Draws the axes for the graph.
*/
protected void drawAxes(Graphics g, long lMaxTime) {
drawGraphString(g, -1, "Alpha vs. Time (ms)", m_nGraphMaxWidth / 2,
m_nGraphMaxHeight + 20);
// draw the frame
drawAreaRect(g, 0, 0, m_nMaxWidth, m_nMaxHeight);
// draw the X axis
drawGraphLine(g, 0, 0, m_nGraphMaxWidth, 0);
// draw the Y axis
drawGraphLine(g, 0, 0, 0, m_nGraphMaxHeight);
// draw the horizontal Y axis lines
for (double yAxisTick = 0; yAxisTick <= 1.0; yAxisTick += 0.2) {
double yTick = yAxisTick * m_nGraphMaxHeight;
g.setColor(Color.gray);
drawGraphLine(g, 0, yTick, m_nGraphMaxWidth, yTick);
g.setColor(Color.black);
drawGraphString(g, 3, "" + yAxisTick, -20, yTick);
}
}
/**
* Draws vertical lines and labels to denote the various phases of the Alpha
* function.
*/
protected void drawPhases(Graphics g, long lMaxTime) {
int nLoop = 1;
if (m_Alpha.getLoopCount() > 0)
nLoop = m_Alpha.getLoopCount();
double curTime = 0;
g.setColor(Color.darkGray);
curTime += m_Alpha.getTriggerTime();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime += m_Alpha.getPhaseDelayDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
double startPhaseTime = 0;
for (int nIteration = 0; nIteration < nLoop; nIteration++) {
startPhaseTime = curTime;
g.setColor(Color.black);
drawGraphString(g, -1, "" + curTime, curTime * m_ScaleX, -20);
g.setColor(Color.darkGray);
if ((m_Alpha.getMode() & Alpha.INCREASING_ENABLE) != 0) {
curTime += m_Alpha.getIncreasingAlphaRampDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime = startPhaseTime + m_Alpha.getIncreasingAlphaDuration()
- m_Alpha.getIncreasingAlphaRampDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime = startPhaseTime + m_Alpha.getIncreasingAlphaDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime += m_Alpha.getAlphaAtOneDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
}
startPhaseTime = curTime;
if ((m_Alpha.getMode() & Alpha.DECREASING_ENABLE) != 0) {
curTime += m_Alpha.getDecreasingAlphaRampDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime = startPhaseTime + m_Alpha.getDecreasingAlphaDuration()
- m_Alpha.getDecreasingAlphaRampDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime = startPhaseTime + m_Alpha.getDecreasingAlphaDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
curTime += m_Alpha.getAlphaAtZeroDuration();
drawGraphLine(g, curTime * m_ScaleX, 0, curTime * m_ScaleX,
m_nGraphMaxHeight);
}
}
g.setColor(Color.black);
}
/**
* Plots the Alpha function into the graph area of the plot.
*/
protected void drawAlpha(Graphics g, long lMaxTime) {
g.setColor(Color.blue);
float value = 0;
m_Alpha.setStartTime(0);
double x1 = 0;
double y1 = 0;
double x2 = 0;
double y2 = 0;
for (long lTime = 0; lTime <= lMaxTime; lTime += m_kTimeStep) {
value = m_Alpha.value(lTime);
x2 = lTime * m_ScaleX;
y2 = value * m_nGraphMaxHeight;
drawGraphLine(g, x1, y1, x2, y2);
x1 = x2;
y1 = y2;
}
g.setColor(Color.black);
}
/**
* AWT paint method that can handle dynamic scale recomputation and graph
* redraw.
*/
public void paint(Graphics g) {
super.paint(g);
long lMaxTime = 0;
if ((m_Alpha.getMode() & Alpha.INCREASING_ENABLE) != 0) {
lMaxTime += m_Alpha.getIncreasingAlphaDuration()
+ m_Alpha.getAlphaAtOneDuration();
}
if ((m_Alpha.getMode() & Alpha.DECREASING_ENABLE) != 0) {
lMaxTime += m_Alpha.getDecreasingAlphaDuration()
+ m_Alpha.getAlphaAtZeroDuration();
}
if (m_Alpha.getLoopCount() > 0)
lMaxTime *= m_Alpha.getLoopCount();
lMaxTime += m_Alpha.getTriggerTime();
lMaxTime += m_Alpha.getPhaseDelayDuration();
computeDrawScale(lMaxTime);
drawAxes(g, lMaxTime);
drawPhases(g, lMaxTime);
drawAlpha(g, lMaxTime);
}
/**
* Simple main method that uses the Java 3D MainFrame helper class.
*/
public static void main(String[] args) {
AlphaTest alphaTest = new AlphaTest();
new MainFrame(alphaTest, m_kWidth, m_kHeight);
}
}
|
