//------------------------------------------------------------------------------//
// BitmapManager SetDisplayData()
//------------------------------------------------------------------------------//
// Function may be used to either set display data or set extemes of data
// displayed. If paramater "StateData' then this function has to have been
// previously called with a non-null 'StateData'
// If parameter 'StateData' is null its corresponding member variable
// 'm_stateData' remains untouched.
public void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData, DATA_EXTREMES_SPE_BITMAP DataExtremes,
DATA_EXTREMES_SPE_BITMAP MovementDataExtremes, Boolean MaintainScaling)
{
// If parameter 'StateData' is null verify it's corresponding member variable isn't.
if(StateData == null)
Debug.Assert(m_stateData != null);
// Assign parameters to their corresponding member variables.
if(StateData != null)
m_stateData = StateData;
// Set up the bitmaps with the new data.
m_diveTimeScale.SetDisplayData(m_stateData, DataExtremes, MaintainScaling);
m_depthScale.SetDisplayData(m_stateData, DataExtremes, MaintainScaling);
m_dive.SetDisplayData(m_stateData, DataExtremes, MaintainScaling);
// Movement map currently always needs the extremes of the actual data passed
// in.
m_movement.SetDisplayData(m_stateData, MovementDataExtremes, MaintainScaling);
m_parentForm.Invalidate();
}
//------------------------------------------------------------------------------//
// Movement Bitmap UpdateDataDisplay()
//------------------------------------------------------------------------------//
public override void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData,
DATA_EXTREMES_SPE_BITMAP StateDataExtremes, Boolean MaintainScaling)
{
int xStartMeters;
int xEndMeters;
int yStartMeters;
int yEndMeters;
base.SetDisplayData(StateData, StateDataExtremes, MaintainScaling);
m_timeStartIndex = 0;
m_timeEndIndex = StateData.Length - 1;
// These are for the hashmarks
xStartMeters = (int)Math.Floor(StateDataExtremes.xMin); // longitude start
xEndMeters = (int)Math.Ceiling(StateDataExtremes.xMax); // longitude end
yStartMeters = (int)Math.Floor(StateDataExtremes.yMin); // latitude start
yEndMeters = (int)Math.Ceiling(StateDataExtremes.yMax); // latitude end
if(xStartMeters < yStartMeters)
m_startMeters = xStartMeters;
else
m_startMeters = yStartMeters;
if(xEndMeters > yEndMeters)
m_endMeters = xEndMeters;
else
m_endMeters = yEndMeters;
RedrawBitmap();
}
//------------------------------------------------------------------------------//
// Dive Scale Bitmap SetDisplayData()
//------------------------------------------------------------------------------//
public override void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData,
DATA_EXTREMES_SPE_BITMAP StateDataExtremes, Boolean MaintainScaling)
{
base.SetDisplayData(StateData, StateDataExtremes, MaintainScaling); // copies it to local variables
if(MaintainScaling == false)
{
// time scale sliders
m_sliderSet.min.point = new Point(m_dataRect.X, m_pixelPosMinTopSlider);
m_sliderSet.max.point = new Point(m_dataRect.X, m_pixelPosMaxBottomSlider);
m_sliderSet.mid.point = new Point(m_dataRect.X + m_dataRect.Width / 2, m_pixelPosMinTopSlider + (m_pixelPosMaxBottomSlider - m_pixelPosMinTopSlider) / 2);
m_scaleValue = (float)(m_pixelPosMaxBottomSlider - m_pixelPosMinTopSlider) / (float)m_sliderRange;
}
}
//------------------------------------------------------------------------------//
// Dive Scale Bitmap SetDisplayData()
//------------------------------------------------------------------------------//
// Called when new data is generated and needs to be displayed.
public override void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData,
DATA_EXTREMES_SPE_BITMAP StateDataExtremes, Boolean MaintainScaling)
{
int i;
int xPixel;
int zPixel;
float delta;
base.SetDisplayData(StateData, StateDataExtremes, MaintainScaling);
m_bitmap = new Bitmap(m_dataRect.Width, m_dataRect.Height);
if(StateData.Length > 1 && m_dataRect.Width > 1)
m_dataScale.x = ((float)m_dataRect.Width-1/*-1 for zero index*/)/(float)(StateData.Length-1); // pixels per datum
else
m_dataScale.x = 1.0F;
delta = (float)(StateDataExtremes.zMax - StateDataExtremes.zMin);
if(delta <= 0)
delta = 1;
if(m_dataRect.Height > 1)
m_dataScale.y = (m_dataRect.Height - 1)/delta; // pixels per datum
else
m_dataScale.y = 1.0F;
for(i=0; i<m_stateData.Length; i++)
{
xPixel = (int)Math.Floor(m_dataScale.x*i); // minus 1 for zero index
zPixel = (int)Math.Floor(m_dataScale.y*(m_stateData[i].z - StateDataExtremes.zMin));
ds.x = m_dataScale.x;
ds.y = m_dataScale.y;
m_bitmap.SetPixel(xPixel, zPixel, GetCurrentBehaviorColor(m_stateData[i].animatState.behavior));
}
// Calculate the number of data points each pixel represents.
m_dataPointsPerPixle = (float)m_stateData.Length / (float)m_dataRect.Width;
if(MaintainScaling == false)
{
// time scale sliders
m_sliderSet.min.point = new Point(m_pixlePntMinLSlider, m_dataRect.Y);
m_sliderSet.max.point = new Point(m_pixlePntMaxRSlider, m_dataRect.Y);
m_sliderSet.mid.point = new Point(m_pixlePntMinLSlider + (m_pixlePntMaxRSlider - m_pixlePntMinLSlider) / 2, m_dataRect.Y + m_dataRect.Height / 2);
m_scaleValue = (float)(m_sliderSet.max.point.X - m_sliderSet.min.point.X) / (float)m_sliderRange;
}
}
private DATA_EXTREMES_SPE_BITMAP DetermineDataExtremes(ANIMATSTATEDATABITMAP[] StateData)
{
int i;
DATA_EXTREMES_SPE_BITMAP ex;
ex.xMax = ex.xMin = StateData[0].x;
ex.yMax = ex.yMin = StateData[0].y;
ex.zMax = ex.zMin = StateData[0].z;
if(ex.zMax < StateData[0].targetDepth)
ex.zMax = StateData[0].targetDepth;
if(ex.zMin > StateData[0].targetDepth)
ex.zMin = StateData[0].targetDepth;
for(i = 0; i < StateData.Length; i++)
{
if(ex.xMax < StateData[i].x)
ex.xMax = StateData[i].x;
if(ex.xMin > StateData[i].x)
ex.xMin = StateData[i].x;
if(ex.yMax < StateData[i].y)
ex.yMax = StateData[i].y;
if(ex.yMin > StateData[i].y)
ex.yMin = StateData[i].y;
if(ex.zMax < StateData[i].z)
ex.zMax = StateData[i].z;
if(ex.zMin > StateData[i].z)
ex.zMin = StateData[i].z;
if(ex.zMax < StateData[i].targetDepth)
ex.zMax = StateData[i].targetDepth;
if(ex.zMin > StateData[i].targetDepth)
ex.zMin = StateData[i].targetDepth;
}
// Give some margin at the top and bottom of the dive profile.
ex.zMin -= 20;
ex.zMax += 20;
return ex;
}
//------------------------------------------------------------------------------//
// Species Bitmap Window Constructor
//------------------------------------------------------------------------------//
public virtual void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData, DATA_EXTREMES_SPE_BITMAP DataExtremes, Boolean MaintainScaling)
{
m_stateData = StateData;
m_dataExtremes = DataExtremes;
m_bMaintainsScaleOnNewData = MaintainScaling;
}
//------------------------------------------------------------------------------//
// Dive Bitmap SetDisplayData()
//------------------------------------------------------------------------------//
public override void SetDisplayData(ANIMATSTATEDATABITMAP[] StateData, DATA_EXTREMES_SPE_BITMAP DataExtremes,
Boolean MaintainScaling)
{
Debug.Assert(StateData != null);
m_stateData = StateData;
m_dataExtremes = DataExtremes;
m_displayInf.noDisplay = false;
if(StateData.Length <= 1)
{
m_displayInf.noDisplay = true;
return;
}
if(MaintainScaling == false)
{
// Initially (until user scales the time) the number of seconds to
// display is equal to the length of the data array passed in.
m_timeStartIndex = 0;
m_timeEndIndex = m_stateData.Length - 1;
m_displayInf.fDepthStartMeters = DataExtremes.zMin;
m_displayInf.fDepthEndMeters = DataExtremes.zMax;
m_displayInf.nDepthStartMeters = (int)Math.Floor(DataExtremes.zMin);
m_displayInf.nDepthEndMeters = (int)Math.Ceiling(DataExtremes.zMax);
// Scale the display based on the passed in display data.
UpdateXYScale();
}
// Redraw the bitmap.
ConstructBitmap();
}
