void GIntSpinBox::Init()
{
m_ShouldEmit_ValueChangedSignificantly = true;
connect(this, SIGNAL(valueChanged(int)), this, SLOT(ReProcessValueChangedSiganl(int)));
setRange(G_DEFAULT_RANGE_MIN, G_DEFAULT_RANGE_MAX);
setKeyboardTracking(false);
setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
UpdateUnits();
connect(m_pParam, SIGNAL(UnitsChanged(QString)), this, SLOT(UpdateUnits()));
connect(m_pParam, SIGNAL(UnitDisplayChanged(bool)), this, SLOT(UpdateUnits()));
}
/////////////////////////////////////////////////////////////////////////////
// ISymbolPropertyPage
STDMETHODIMP CLogoMarkerPropertyPage::put_Units(esriUnits Units)
{
if (m_lUnits != Units)
{
m_lUnits = Units;
UpdateUnits();
}
return S_OK;
}
void EventBatchHandler::UpdateObjects() {
{
GML_STDMUTEX_LOCK(runit); // UpdateObjects
UpdateUnits();
}
{
GML_STDMUTEX_LOCK(rfeat); // UpdateObjects
UpdateFeatures();
}
{
GML_STDMUTEX_LOCK(rproj); // UpdateObjects
UpdateProjectiles();
}
}
void ReportAnthropometry::OnUpdate(CView* aSenderPtr,
LPARAM aHint,
CObject* aHintPtr)
{
C_Hom_Doc* lDocPtr = static_cast <C_Hom_Doc*> (GetDocument());
Factors mFactors;
String s = "Male";
if(lDocPtr->Gender() == s)
mFactors.RestoreMaleDefaults();
else
mFactors.RestoreFemaleDefaults();
double mCM_Hand = mFactors.mCM_Hand;
double mCM_Forearm = mFactors.mCM_Forearm;
double mCM_Upperarm = mFactors.mCM_Upperarm;
double mCM_UpperNeck = mFactors.mCM_UpperNeck;
double mCM_LowerNeck = mFactors.mCM_LowerNeck;
double mCM_Head = mFactors.mCM_Head;
double mCM_L5S1ToShoulder = mFactors.mCM_L5S1ToShoulder;
double mCM_Pelvis = mFactors.mCM_Pelvis;
double mCM_UpperLeg = mFactors.mCM_UpperLeg;
double mCM_LowerLeg = mFactors.mCM_LowerLeg;
double mCM_Foot = mFactors.mCM_Foot;
mHeader = lDocPtr->ReportHeader();
const LinkLengths& lengths = lDocPtr->getLinkLengths();
const LinkWeights& weights = lDocPtr->getLinkWeights();
const LinkCGs& CGs = lDocPtr->getLinkCGs();
mLengthLabel = CString("Length (")+ lDocPtr->LengthUnits() + ")";
mCGLabel = CString("CG-to-Proximal End\nDistance (")
+ lDocPtr->LengthUnits() + ")";
mWeightLabel = CString("Weight (")+ lDocPtr->ForceUnits() + ")";
double lengthConversion, forceConversion;
if(lDocPtr->Is_English()) {
lengthConversion = 0.39370;
forceConversion = 0.224808;
} else {
lengthConversion = 1;
forceConversion = 1;
}
// TODO unit conversions
/* mFootCG.Format("%.1f",lengthConversion * CGs.Foot);//lDocPtr->getFootCG().ValueText();
mFootL.Format("%.1f",lengthConversion * lengths.HeelToToe);//lDocPtr->getFootL().ValueText();
if(Dg_Anthropometry::isred[16] == True)
mFootCG.Format("%.1f",atof(mFootL) * mCM_Foot);*/
/*if(atof(mFootL) != Round_Double(Dg_Anthropometry::backl[16],1) && atof(mFootCG) == Round_Double(Dg_Anthropometry::backl[17],1))
{
mFootL.Format("%.1f",lengthConversion * lengths.HeelToToe);
mFootCG.Format("%.1f",atof(mFootL) * mCM_Foot);
Dg_Anthropometry::backl[16] = atof(mFootL);
Dg_Anthropometry::backl[17] = atof(mFootCG);
}
else
{*/
mFootL.Format("%.1f",lengthConversion * lengths.HeelToToe);//mDocPtr->getHandCG().ValueText();
mFootCG.Format("%.1f",lengthConversion * CGs.Foot);//mDocPtr->getHandWithFingersL().ValueText();
/*Dg_Anthropometry::backl[16] = atof(mFootL);
Dg_Anthropometry::backl[17] = atof(mFootCG);
}*/
mFootWt.Format("%.1f",forceConversion * weights.Foot);//lDocPtr->getFootWt().ValueText();
/* if(atof(mFootLR) != Round_Double(Dg_Anthropometry::backr[16],1) && atof(mFootCGR) == Round_Double(Dg_Anthropometry::backr[17],1))
{
mFootLR.Format("%.1f",lengthConversion * lengths.HeelToToeR);
mFootCGR.Format("%.1f",atof(mFootLR) * mCM_Foot);
Dg_Anthropometry::backr[16] = atof(mFootLR);
Dg_Anthropometry::backr[17] = atof(mFootCGR);
}
else
{*/
mFootLR.Format("%.1f",lengthConversion * lengths.HeelToToeR);//mDocPtr->getHandCG().ValueText();
mFootCGR.Format("%.1f",lengthConversion * CGs.FootR);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backr[16] = atof(mFootLR);
Dg_Anthropometry::backr[17] = atof(mFootCGR);
}*/
/*mFootCGR.Format("%.1f",lengthConversion * CGs.FootR);//lDocPtr->getFootCG().ValueText();
mFootLR.Format("%.1f",lengthConversion * lengths.HeelToToeR);//lDocPtr->getFootL().ValueText();
if(Dg_Anthropometry::isred[16] == True)
mFootCGR.Format("%.1f",atof(mFootLR) * mCM_Foot);*/
mFootWtR.Format("%.1f",forceConversion * weights.FootR);//lDocPtr->getFootWt().ValueText();
/* if(atof(mHipToL5L) != Round_Double(Dg_Anthropometry::backl[32],1) && atof(mHipToL5CG) == Round_Double(Dg_Anthropometry::backl[33],1))
{
mHipToL5L.Format("%.1f",lengthConversion * lengths.HipToL5S1);//mDocPtr->getHandWithFingersL().ValueText();
mHipToL5CG.Format("%.1f",atof(mHipToL5L) * mCM_Pelvis);
Dg_Anthropometry::backl[32] = atof(mHipToL5L);
Dg_Anthropometry::backl[33] = atof(mHipToL5L);
}
else
}*/ mHipToL5CG.Format("%.1f",lengthConversion * CGs.Pelvis);//mDocPtr->getHandCG().ValueText();
mHipToL5L.Format("%.1f",lengthConversion * lengths.HipToL5S1);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[32] = atof(mHipToL5L);
Dg_Anthropometry::backl[33] = atof(mHipToL5L);
}*/
/*mHipToL5CG.Format("%.1f",lengthConversion * CGs.Pelvis);//lDocPtr->getHipToL5CG().ValueText();
mHipToL5L.Format("%.1f",lengthConversion * lengths.HipToL5S1);//lDocPtr->getHipToL5L().ValueText();
if(Dg_Anthropometry::isred[32] == True)
mHipToL5CG.Format("%.1f",atof(mHipToL5L) * mCM_Pelvis);*/
mHipToL5Wt.Format("%.1f",forceConversion * weights.Pelvis);//lDocPtr->getHipToL5Wt().ValueText();
mHipToHipL.Format("%.1f",lengthConversion * lengths.HipToHip);//lDocPtr->getHipToHipL().ValueText();
//mHipToHipWt = lDocPtr->getHipToHipWt().ValueText();
//mHipToShoulderL.Format("%.1f",lengthConversion * lengths.HipToShoulder);//lDocPtr->getHipToShoulderL().ValueText();
//mHipToShoulderWt.Format("%.1f",forceConversion * weights.TorsoAndHead + forceConversion * weights.Pelvis);//lDocPtr->getHipToShoulderWt().ValueText();
/* if(atof(mL5ToShoulderL) != Round_Double(Dg_Anthropometry::backl[29],1) && atof(mL5ToShoulderCG) == Round_Double(Dg_Anthropometry::backl[30],1))
{
mL5ToShoulderL.Format("%.1f",lengthConversion * lengths.L5S1ToC7T1);//mDocPtr->getHandWithFingersL().ValueText();
mL5ToShoulderCG.Format("%.1f",atof(mL5ToShoulderL) * mCM_L5S1ToShoulder);
Dg_Anthropometry::backl[29] = atof(mL5ToShoulderL);
Dg_Anthropometry::backl[30] = atof(mL5ToShoulderCG);
}
else
{*/
mL5ToShoulderCG.Format("%.1f",lengthConversion * CGs.L5S1ToShoulder);//mDocPtr->getHandCG().ValueText();
mL5ToShoulderL.Format("%.1f",lengthConversion * lengths.L5S1ToC7T1);//mDocPtr->getHandWithFingersL().ValueText();
/*Dg_Anthropometry::backl[29] = atof(mL5ToShoulderL);
Dg_Anthropometry::backl[30] = atof(mL5ToShoulderCG);
}*/
/*mL5ToShoulderCG.Format("%.1f",lengthConversion * CGs.L5S1ToShoulder);//lDocPtr->getL5ToShoulderCG().ValueText();
mL5ToShoulderL.Format("%.1f",lengthConversion * lengths.L5S1ToShoulder);//lDocPtr->getL5ToShoulderL().ValueText();
if(Dg_Anthropometry::isred[29] == True)
mL5ToShoulderCG.Format("%.1f",atof(mL5ToShoulderL) * mCM_L5S1ToShoulder);*/
mL5ToShoulderWt.Format("%.1f",forceConversion * weights.TorsoAndHead);//lDocPtr->getL5ToShoulderWt().ValueText();
//mHandCG.Format("%.1f",lengthConversion * CGs.Hand);//lDocPtr->getHandCG().ValueText();
mHandL.Format("%.1f",lengthConversion * lengths.Hand);//lDocPtr->getHandL().ValueText();
//mHandWt.Format("%.1f",forceConversion * weights.Hand);//lDocPtr->getHandWt().ValueText();
//mHandCGR.Format("%.1f",lengthConversion * CGs.HandR);//lDocPtr->getHandCG().ValueText();
mHandLR.Format("%.1f",lengthConversion * lengths.HandR);//lDocPtr->getHandL().ValueText();
//mHandWtR.Format("%.1f",forceConversion * weights.HandR);//lDocPtr->getHandWt().ValueText();
/* if(atof(mHeadL) != Round_Double(Dg_Anthropometry::backl[19],1) && atof(mHeadCG) == Round_Double(Dg_Anthropometry::backl[20],1))
{
mHeadL.Format("%.1f",lengthConversion * lengths.C1Tragion);//mDocPtr->getHandWithFingersL().ValueText();
mHeadCG.Format("%.1f",lengthConversion * CGs.Head);
Dg_Anthropometry::backl[19] = atof(mHeadL);
Dg_Anthropometry::backl[20] = atof(mHeadCG);
}
else
{*/
mHeadCG.Format("%.1f",lengthConversion * CGs.Head);//mDocPtr->getHandCG().ValueText();
mHeadL.Format("%.1f",lengthConversion * lengths.C1Tragion);//mDocPtr->getHandWithFingersL().ValueText();
/*Dg_Anthropometry::backl[19] = atof(mHeadL);
Dg_Anthropometry::backl[20] = atof(mHeadCG);
}*/
/* mHeadCG.Format("%.1f",lengthConversion * CGs.Head);//lDocPtr->getHeadCG().ValueText();
mHeadL.Format("%.1f",lengthConversion * lengths.C1Tragion);//lDocPtr->getHeadL().ValueText();
if(Dg_Anthropometry::isred[19] == True)
mHeadCG.Format("%.1f",atof(mHeadL) * mCM_Head);*/
mHeadWt.Format("%.1f",forceConversion * weights.Head);//lDocPtr->getHeadWt().ValueText();
mNasionL.Format("%.1f",lengthConversion * lengths.HeadRadius);
mNeck1CG.Format("%.1f",lengthConversion * CGs.UpperNeck);
mNeck1L.Format("%.1f",lengthConversion * lengths.C1C3);//lDocPtr->getHeadL().ValueText();
mNeck1Wt.Format("%.1f",forceConversion * weights.UpperNeck);
mNeck2CG.Format("%.1f",lengthConversion * CGs.LowerNeck);
mNeck2L.Format("%.1f",lengthConversion * lengths.C4C7);//lDocPtr->getHeadL().ValueText();
mNeck2Wt.Format("%.1f",forceConversion * weights.LowerNeck);
/* if(atof(mNeck2L) != Round_Double(Dg_Anthropometry::backl[26],1) && atof(mNeck2CG) == Round_Double(Dg_Anthropometry::backl[27],1))
{
mNeck2L.Format("%.1f",lengthConversion * lengths.C4C7);//mDocPtr->getHandWithFingersL().ValueText();
mNeck2CG.Format("%.1f",atof(mNeck2L) * mCM_LowerNeck);
Dg_Anthropometry::backl[26] = atof(mNeck2L);
Dg_Anthropometry::backl[27] = atof(mNeck2CG);
}
else
{
mNeck2CG.Format("%.1f",lengthConversion * CGs.LowerNeck);//mDocPtr->getHandCG().ValueText();
mNeck2L.Format("%.1f",lengthConversion * lengths.C4C7);//mDocPtr->getHandWithFingersL().ValueText();
Dg_Anthropometry::backl[26] = atof(mNeck2L);
Dg_Anthropometry::backl[27] = atof(mNeck2CG);
}
*/
/*mNeck2CG.Format("%.1f",lengthConversion * CGs.LowerNeck);//lDocPtr->getNeck2CG().ValueText();
mNeck2L.Format("%.1f",lengthConversion * lengths.C4C7);//lDocPtr->getNeck2L().ValueText();
if(Dg_Anthropometry::isred[26] == True)
mNeck2CG.Format("%.1f",atof(mNeck2L) * mCM_LowerNeck);*/
//mNeck2Wt.Format("%.1f",forceConversion * weights.LowerNeck);//lDocPtr->getNeck2Wt().ValueText();
/* if(atof(mHandWithFingersL) != Round_Double(Dg_Anthropometry::backl[1],1) && atof(mHandWithFingersCG) == Round_Double(Dg_Anthropometry::backl[2],1))
{ //if user only change the length value or change them both ,then CG should be changed correspondlingly
mHandWithFingersL.Format("%.1f",lengthConversion * lengths.HandWithFingers);
mHandWithFingersCG.Format("%.1f",atof(mHandWithFingersL) * mCM_Hand);
Dg_Anthropometry::backl[1] = atof(mHandWithFingersL);
Dg_Anthropometry::backl[2] = atof(mHandWithFingersCG);
}
else //if user only change the CG or does not change anything ,then let the value be what the user input.This means changing the CG will not lead to the adjustment of its length,however.
{*/
mHandWithFingersCG.Format("%.1f",lengthConversion * CGs.Hand);//mDocPtr->getHandCG().ValueText();
mHandWithFingersL.Format("%.1f",lengthConversion * lengths.HandWithFingers);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[1] = atof(mHandWithFingersL);
Dg_Anthropometry::backl[2] = atof(mHandWithFingersCG);
}*/
/*mHandWithFingersCG.Format("%.1f",lengthConversion * CGs.Hand);//lDocPtr->getHandCG().ValueText();
mHandWithFingersL.Format("%.1f",lengthConversion * lengths.HandWithFingers);//lDocPtr->getHandWithFingersL().ValueText();
if(Dg_Anthropometry::isred[1] == True)
mHandWithFingersCG.Format("%.1f",atof(mHandWithFingersL) * mCM_Hand);*/
mHandWithFingersWt.Format("%.1f",forceConversion * weights.Hand);//lDocPtr->getHandWt().ValueText();
/* if(atof(mHandWithFingersLR) != Round_Double(Dg_Anthropometry::backr[1],1) && atof(mHandWithFingersCGR) == Round_Double(Dg_Anthropometry::backr[2],1))
{ //if user only change the length value or change them both ,then CG should be changed correspondlingly
mHandWithFingersLR.Format("%.1f",lengthConversion * lengths.HandWithFingersR);
mHandWithFingersCGR.Format("%.1f",atof(mHandWithFingersLR) * mCM_Hand);
Dg_Anthropometry::backr[1] = atof(mHandWithFingersLR);
Dg_Anthropometry::backr[2] = atof(mHandWithFingersCGR);
}
else //if user only change the CG or does not change anything ,then let the value be what the user input.This means changing the CG will not lead to the adjustment of its length,however.
{*/
mHandWithFingersCGR.Format("%.1f",lengthConversion * CGs.HandR);//mDocPtr->getHandCG().ValueText();
mHandWithFingersLR.Format("%.1f",lengthConversion * lengths.HandWithFingersR);//mDocPtr->getHandWithFingersL().ValueText();
/*Dg_Anthropometry::backr[1] = atof(mHandWithFingersLR);
Dg_Anthropometry::backr[2] = atof(mHandWithFingersCGR);
}*/
/*mHandWithFingersCGR.Format("%.1f",lengthConversion * CGs.HandR);//lDocPtr->getHandCG().ValueText();
mHandWithFingersLR.Format("%.1f",lengthConversion * lengths.HandWithFingersR);//lDocPtr->getHandWithFingersL().ValueText();
if(Dg_Anthropometry::isred[1] == True)
mHandWithFingersCGR.Format("%.1f",atof(mHandWithFingersLR) * mCM_Hand);*/
mHandWithFingersWtR.Format("%.1f",forceConversion * weights.HandR);//lDocPtr->getHandWt().ValueText();
/*if(atof(mLowerArmL) != Round_Double(Dg_Anthropometry::backl[4],1) && atof(mLowerArmCG) == Round_Double(Dg_Anthropometry::backl[5],1))
{
mLowerArmL.Format("%.1f",lengthConversion * lengths.Forearm);//mDocPtr->getHandWithFingersL().ValueText();
mLowerArmCG.Format("%.1f",atof(mLowerArmL) * mCM_Forearm);
Dg_Anthropometry::backl[4] = atof(mLowerArmL);
Dg_Anthropometry::backl[5] = atof(mLowerArmCG);
}
else
{*/
mLowerArmCG.Format("%.1f",lengthConversion * CGs.Forearm);//mDocPtr->getHandCG().ValueText();
mLowerArmL.Format("%.1f",lengthConversion * lengths.Forearm);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[4] = atof(mLowerArmL);
Dg_Anthropometry::backl[5] = atof(mLowerArmCG);
}*/
/*mLowerArmCG.Format("%.1f",lengthConversion * CGs.Forearm);//lDocPtr->getLowerArmCG().ValueText();
mLowerArmL.Format("%.1f",lengthConversion * lengths.Forearm);//lDocPtr->getLowerArmL().ValueText();
if(Dg_Anthropometry::isred[4] == True)
mLowerArmCG.Format("%.1f",atof(mLowerArmL) * mCM_Forearm);*/
mLowerArmWt.Format("%.1f",forceConversion * weights.Forearm);//lDocPtr->getLowerArmWt().ValueText();
/* if(atof(mLowerArmLR) != Round_Double(Dg_Anthropometry::backr[4],1) && atof(mLowerArmCGR) == Round_Double(Dg_Anthropometry::backr[5],1))
{
mLowerArmLR.Format("%.1f",lengthConversion * lengths.ForearmR);//mDocPtr->getHandWithFingersL().ValueText();
mLowerArmCGR.Format("%.1f",atof(mLowerArmLR) * mCM_Forearm);
Dg_Anthropometry::backr[4] = atof(mLowerArmLR);
Dg_Anthropometry::backr[5] = atof(mLowerArmCGR);
}
else
{*/
mLowerArmCGR.Format("%.1f",lengthConversion * CGs.ForearmR);//mDocPtr->getHandCG().ValueText();
mLowerArmLR.Format("%.1f",lengthConversion * lengths.ForearmR);//mDocPtr->getHandWithFingersL().ValueText();
/*Dg_Anthropometry::backr[4] = atof(mLowerArmLR);
Dg_Anthropometry::backr[5] = atof(mLowerArmCGR);
}*/
/*mLowerArmCGR.Format("%.1f",lengthConversion * CGs.ForearmR);//lDocPtr->getLowerArmCG().ValueText();
mLowerArmLR.Format("%.1f",lengthConversion * lengths.ForearmR);//lDocPtr->getLowerArmL().ValueText();
if(Dg_Anthropometry::isred[4] == True)
mLowerArmCGR.Format("%.1f",atof(mLowerArmLR) * mCM_Forearm);*/
mLowerArmWtR.Format("%.1f",forceConversion * weights.ForearmR);//lDocPtr->getLowerArmWt().ValueText();
/* if(atof(mLowerLegL) != Round_Double(Dg_Anthropometry::backl[13],1) && atof(mLowerLegCG) == Round_Double(Dg_Anthropometry::backl[14],1))
{
mLowerLegL.Format("%.1f",lengthConversion * lengths.LowerLeg);//mDocPtr->getHandWithFingersL().ValueText();
mLowerLegCG.Format("%.1f",atof(mLowerLegL) * mCM_LowerLeg);
Dg_Anthropometry::backl[13] = atof(mLowerLegL);
Dg_Anthropometry::backl[14] = atof(mLowerLegCG);
}
else
{*/
mLowerLegCG.Format("%.1f",lengthConversion * CGs.LowerLeg);//mDocPtr->getHandCG().ValueText();
mLowerLegL.Format("%.1f",lengthConversion * lengths.LowerLeg);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[13] = atof(mLowerLegL);
Dg_Anthropometry::backl[14] = atof(mLowerLegCG);
}*/
/*mLowerLegCG.Format("%.1f",lengthConversion * CGs.LowerLeg);//lDocPtr->getLowerLegCG().ValueText();
mLowerLegL.Format("%.1f",lengthConversion * lengths.LowerLeg);//lDocPtr->getLowerLegL().ValueText();
if(Dg_Anthropometry::isred[13] == True)
mLowerLegCG.Format("%.1f",atof(mLowerLegL) * mCM_LowerLeg);*/
mLowerLegWt.Format("%.1f",forceConversion * weights.LowerLeg);//lDocPtr->getLowerLegWt().ValueText();
/*if(atof(mLowerLegLR) != Round_Double(Dg_Anthropometry::backr[13],1) && atof(mLowerLegCGR) == Round_Double(Dg_Anthropometry::backr[14],1))
{
mLowerLegLR.Format("%.1f",lengthConversion * lengths.LowerLegR);//mDocPtr->getHandWithFingersL().ValueText();
mLowerLegCGR.Format("%.1f",atof(mLowerLegLR) * mCM_LowerLeg);
Dg_Anthropometry::backr[13] = atof(mLowerLegLR);
Dg_Anthropometry::backr[14] = atof(mLowerLegCGR);
}
else
*/
mLowerLegCGR.Format("%.1f",lengthConversion * CGs.LowerLegR);//mDocPtr->getHandCG().ValueText();
mLowerLegLR.Format("%.1f",lengthConversion * lengths.LowerLegR);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backr[13] = atof(mLowerLegLR);
Dg_Anthropometry::backr[14] = atof(mLowerLegCGR);
}*/
/*mLowerLegCGR.Format("%.1f",lengthConversion * CGs.LowerLegR);//lDocPtr->getLowerLegCG().ValueText();
mLowerLegLR.Format("%.1f",lengthConversion * lengths.LowerLegR);//lDocPtr->getLowerLegL().ValueText();
if(Dg_Anthropometry::isred[13] == True)
mLowerLegCGR.Format("%.1f",atof(mLowerLegLR) * mCM_LowerLeg);*/
mLowerLegWtR.Format("%.1f",forceConversion * weights.LowerLegR);//lDocPtr->getLowerLegWt().ValueText();
/* if(atof(mUpperArmL) != Round_Double(Dg_Anthropometry::backl[7],1) && atof(mUpperArmCG) == Round_Double(Dg_Anthropometry::backl[8],1))
{
mUpperArmL.Format("%.1f",lengthConversion * lengths.UpperArm);//mDocPtr->getHandWithFingersL().ValueText();
mUpperArmCG.Format("%.1f",atof(mUpperArmL) * mCM_Upperarm);
Dg_Anthropometry::backl[7] = atof(mUpperArmL);
Dg_Anthropometry::backl[8] = atof(mUpperArmCG);
}
else
{*/
mUpperArmCG.Format("%.1f",lengthConversion * CGs.UpperArm);//mDocPtr->getHandCG().ValueText();
mUpperArmL.Format("%.1f",lengthConversion * lengths.UpperArm);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[7] = atof(mUpperArmL);
Dg_Anthropometry::backl[8] = atof(mUpperArmCG);
}*/
/*mUpperArmCG.Format("%.1f",lengthConversion * CGs.UpperArm);//lDocPtr->getUpperArmCG().ValueText();
mUpperArmL.Format("%.1f",lengthConversion * lengths.UpperArm);//lDocPtr->getUpperArmL().ValueText();
if(Dg_Anthropometry::isred[7] == True)
mUpperArmCG.Format("%.1f",atof(mUpperArmL) * mCM_Upperarm);*/
mUpperArmWt.Format("%.1f",forceConversion * weights.UpperArm);//lDocPtr->getUpperArmWt().ValueText();
/* if(atof(mUpperArmLR) != Round_Double(Dg_Anthropometry::backr[7],1) && atof(mUpperArmCGR) == Round_Double(Dg_Anthropometry::backr[8],1))
{
mUpperArmLR.Format("%.1f",lengthConversion * lengths.UpperArmR);//mDocPtr->getHandWithFingersL().ValueText();
mUpperArmCGR.Format("%.1f",atof(mUpperArmLR) * mCM_Upperarm);
Dg_Anthropometry::backr[7] = atof(mUpperArmLR);
Dg_Anthropometry::backr[8] = atof(mUpperArmCGR);
}
else
{*/
mUpperArmCGR.Format("%.1f",lengthConversion * CGs.UpperArmR);//mDocPtr->getHandCG().ValueText();
mUpperArmLR.Format("%.1f",lengthConversion * lengths.UpperArmR);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backr[7] = atof(mUpperArmLR);
Dg_Anthropometry::backr[8] = atof(mUpperArmCGR);
}*/
/*mUpperArmCGR.Format("%.1f",lengthConversion * CGs.UpperArmR);//lDocPtr->getUpperArmCG().ValueText();
mUpperArmLR.Format("%.1f",lengthConversion * lengths.UpperArmR);//lDocPtr->getUpperArmL().ValueText();
if(Dg_Anthropometry::isred[7] == True)
mUpperArmCGR.Format("%.1f",atof(mUpperArmLR) * mCM_Upperarm);*/
mUpperArmWtR.Format("%.1f",forceConversion * weights.UpperArmR);//lDocPtr->getUpperArmWt().ValueText();
/* if((atof(mUpperLegL) != Round_Double(Dg_Anthropometry::backl[10],1) && atof(mUpperLegCG) == Round_Double(Dg_Anthropometry::backl[11],1)))
{
mUpperLegL.Format("%.1f",lengthConversion * lengths.UpperLeg);//mDocPtr->getHandWithFingersL().ValueText();
mUpperLegCG.Format("%.1f",atof(mUpperLegL) * mCM_UpperLeg);
Dg_Anthropometry::backl[10] = atof(mUpperLegL);
Dg_Anthropometry::backl[11] = atof(mUpperLegCG);
}
else
{*/
mUpperLegCG.Format("%.1f",lengthConversion * CGs.UpperLeg);//mDocPtr->getHandCG().ValueText();
mUpperLegL.Format("%.1f",lengthConversion * lengths.UpperLeg);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backl[10] = atof(mUpperLegL);
Dg_Anthropometry::backl[11] = atof(mUpperLegCG);
}*/
/*mUpperLegCG.Format("%.1f",lengthConversion * CGs.UpperLeg);//lDocPtr->getUpperLegCG().ValueText();
mUpperLegL.Format("%.1f",lengthConversion * lengths.UpperLeg);//lDocPtr->getUpperLegL().ValueText();
if(Dg_Anthropometry::isred[10] == True)
mUpperLegCG.Format("%.1f",atof(mUpperLegL) * mCM_UpperLeg);*/
mUpperLegWt.Format("%.1f",forceConversion * weights.UpperLeg);//lDocPtr->getUpperLegWt().ValueText();
/* if((atof(mUpperLegLR) != Round_Double(Dg_Anthropometry::backr[10],1) && atof(mUpperLegCGR) == Round_Double(Dg_Anthropometry::backr[11],1)))
{
mUpperLegLR.Format("%.1f",lengthConversion * lengths.UpperLegR);//mDocPtr->getHandWithFingersL().ValueText();
mUpperLegCGR.Format("%.1f",atof(mUpperLegLR) * mCM_UpperLeg);
Dg_Anthropometry::backr[10] = atof(mUpperLegLR);
Dg_Anthropometry::backr[11] = atof(mUpperLegCGR);
}
else
{*/
mUpperLegCGR.Format("%.1f",lengthConversion * CGs.UpperLegR);//mDocPtr->getHandCG().ValueText();
mUpperLegLR.Format("%.1f",lengthConversion * lengths.UpperLegR);//mDocPtr->getHandWithFingersL().ValueText();
/* Dg_Anthropometry::backr[10] = atof(mUpperLegLR);
Dg_Anthropometry::backr[11] = atof(mUpperLegCGR);
}*/
/* mUpperLegCGR.Format("%.1f",lengthConversion * CGs.UpperLegR);//lDocPtr->getUpperLegCG().ValueText();
mUpperLegLR.Format("%.1f",lengthConversion * lengths.UpperLegR);//lDocPtr->getUpperLegL().ValueText();
if(Dg_Anthropometry::isred[10] == True)
mUpperLegCGR.Format("%.1f",atof(mUpperLegLR) * mCM_UpperLeg);*/
mUpperLegWtR.Format("%.1f",forceConversion * weights.UpperLegR);//lDocPtr->getUpperLegWt().ValueText();
Skeleton* skel = lDocPtr->GetSkeleton();
const LowBackSagittalData_s& sagittal = skel->getLowBackSagittalData();
mDiaphramMomentL.Format("%.1f",sagittal.diaphramMomentArm);//lDocPtr->getDiaphramMomentL().ValueText();
mUpperBodyWt.Format("%.1f",(skel->getNetForce(JT_L5S1_TEMP) - skel->getNetForce(JT_LHAND) - skel->getNetForce(JT_RHAND)).length());//lDocPtr->getUpperBodyWt().ValueText();
// mShoulderToShoulderL.Format("%.1f",lengthConversion * lengths.ShoulderWidth);//lDocPtr->getShoulderToShoulderL().ValueText();
mUpperBodyL.Format("%.1f",lengthConversion * CGs.UpperLegR);
mUpperBodyCG.Format("%.1f",(skel->getNetForce(JT_L5S1_TEMP) - skel->getNetForce(JT_LHAND) - skel->getNetForce(JT_RHAND)).length());
mFactorsName = lDocPtr->GetFactors().mName;
mFooter = lDocPtr->ReportFooter();
UpdateData(FALSE);
UpdateUnits();
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
InvalidateRect(0);
}
//---------------------------------------------------------------------------
void ReportJointLocations::OnUpdate(CView * aSenderPtr,
LPARAM aHint,
CObject * aHintPtr
)
{
C_Hom_Doc * lDocPtr = (C_Hom_Doc*)GetDocument();
mHeader = lDocPtr->ReportHeader();
bool standing = lDocPtr->getPosition() == P_Standing;
//--- Joint Locations ---
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
//--------------------------------------
mLocationUnits = CString("Locations ") + "(" + lDocPtr->LengthUnits() + ")";
Vector3 tempPoint;
Vector3 offsetCoordinate = lDocPtr->getOffset();
for(int i = 0; i < NUM_JOINTS; i++) { // *****33 must be replaced by NUM_JOINTS once the locations of hand joints are being handled properly*****
if(jointToMember[i]) {
tempPoint = lSkeleton.getJoint((JointID)i);
for(int j = 0; j < 3; j++) {
switch (j) {
case 0:
jointToMember[i][j].Format("%.1f", (tempPoint[j] - offsetCoordinate[0]));
break;
case 1:
jointToMember[i][j].Format("%.1f", (tempPoint[j] - offsetCoordinate[1]));
break;
case 2:
jointToMember[i][j].Format("%.1f", (tempPoint[j] - offsetCoordinate[2]));
break;
}
}
}
}
bool backrest = lDocPtr->hasSeatBackRest();
if(!standing) {
Vector3 rightFrontSeat = lSkeleton.getRightSeatFront() - offsetCoordinate;
Vector3 leftFrontSeat = lSkeleton.getLeftSeatFront() - offsetCoordinate;
Vector3 seatBack = lSkeleton.getSeatBackCenter() - offsetCoordinate;
Vector3 SRP = lSkeleton.getSeatReference() - offsetCoordinate;
Vector3 forwardSeat = lSkeleton.getSeatCenter() - offsetCoordinate;
for(int i = 0; i < 3; i++) {
mRightForSeat[i].Format("%.1f", rightFrontSeat[i]);
mLeftForSeat[i].Format("%.1f", leftFrontSeat[i]);
mSeatBack[i].Format("%.1f", seatBack[i]);
mSRP[i].Format("%.1f", SRP[i]);
mSeatForward[i].Format("%.1f", forwardSeat[i]);
if(!backrest) {
mSeatBack[i] = "---";
}
}
} else {
for(int i = 0; i < 3; ++i) {
mLeftITLoc[i] = "---";
mRightITLoc[i] = "---";
mLeftForSeat[i] = "---";
mRightForSeat[i] = "---";
mITCenter[i] = "---";
mSeatBack[i] = "---";
mSeatForward[i] = "---";
mSRP[i] = "---";
}
}
this->GetDlgItem(IDC_LeftITLocX)->EnableWindow(!standing);
this->GetDlgItem(IDC_LeftITLocY)->EnableWindow(!standing);
this->GetDlgItem(IDC_LeftITLocZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_RightITLocX)->EnableWindow(!standing);
this->GetDlgItem(IDC_RightITLocY)->EnableWindow(!standing);
this->GetDlgItem(IDC_RightITLocZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_LEFTFORSEATX)->EnableWindow(!standing);
this->GetDlgItem(IDC_LEFTFORSEATY)->EnableWindow(!standing);
this->GetDlgItem(IDC_LEFTFORSEATZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_RIGHTFORSEATX)->EnableWindow(!standing);
this->GetDlgItem(IDC_RIGHTFORSEATY)->EnableWindow(!standing);
this->GetDlgItem(IDC_RIGHTFORSEATZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_ITCenterLocX)->EnableWindow(!standing);
this->GetDlgItem(IDC_ITCenterLocY)->EnableWindow(!standing);
this->GetDlgItem(IDC_ITCenterLocZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_SeatBackLocX)->EnableWindow(!standing && backrest);
this->GetDlgItem(IDC_SeatBackLocY)->EnableWindow(!standing && backrest);
this->GetDlgItem(IDC_SeatBackLocZ)->EnableWindow(!standing && backrest);
this->GetDlgItem(IDC_ForwardSeatLocX)->EnableWindow(!standing);
this->GetDlgItem(IDC_ForwardSeatLocY)->EnableWindow(!standing);
this->GetDlgItem(IDC_ForwardSeatLocZ)->EnableWindow(!standing);
this->GetDlgItem(IDC_SRPLocX)->EnableWindow(!standing);
this->GetDlgItem(IDC_SRPLocY)->EnableWindow(!standing);
this->GetDlgItem(IDC_SRPLocZ)->EnableWindow(!standing);
mFooter = lDocPtr->ReportFooter();
UpdateData( FALSE );
UpdateUnits();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
//Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
return;
}
void ReportPosture::OnUpdate(CView *aSenderPtr,
LPARAM aHint,
CObject * aHintPtr)
{
C_Hom_Doc * lDocPtr = (C_Hom_Doc*)GetDocument();
//Analysis &lResult = lDocPtr->getResultsRef();
//--- Additional hip angles
//JointAngles docJointAngles;
Skeleton& skel = *lDocPtr->GetSkeleton();
/*unsigned int frame = lDocPtr->GetSkeleton().getCurrentFrame();
lDocPtr->GetSkeleton().GetAngles(frame,docJointAngles);*/
//--- Assign dialog members ---
mLeftElbowIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_ElbowLInc)));//lResult.LeftElbowIncluded()));
mLeftShoulderVert = IntToCStr(Round_Double(skel.getExtraAngle(EA_ShoulderLV)));//lResult.LeftShoulderVertical()));
mLeftShoulderHorz = IntToCStr(Round_Double(skel.getExtraAngle(EA_ShoulderLH)));//lResult.LeftShoulderHorizontal()));
mLeftHumeralRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_HumerusLRot)));//lResult.LeftHumeralRotation()));
mLeftForearmRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_ForearmLRot)));
// 09/17/07 Sayan
// We comment this out as we will be showing Flexion and Extension separately.
// mLeftHandFlexion = IntToCStr(int(skel.getExtraAngle(EA_HandLFlexion)));
// Flexion is always negative and Extension is always positive?
if ((int(skel.getExtraAngle(EA_HandLFlexion))) >=0) {
mLeftHandExtension = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandLFlexion)));
mLeftHandFlexion = IntToCStr(0);
} else {
mLeftHandFlexion = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandLFlexion)));
mLeftHandExtension = IntToCStr(0);
}
// mLeftHandFlexion = IntToCStr(int(skel.getExtraAngle(EA_HandLFlexion)));
// mLeftHandDeviation = IntToCStr(int(skel.getExtraAngle(EA_HandLDeviation)));
// 09/17/07 Sayan
// We comment this out as we will be showing ulnar deviation and radial deviation separately.
// mRightHandDeviation = IntToCStr(int(skel.getExtraAngle(EA_HandRDeviation)));
// Radial deviation is always negative and ulnar deviation is always positive?
if ((int(skel.getExtraAngle(EA_HandLDeviation))) >=0) {
mLeftHandUlnarDeviation = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandLDeviation)));
mLeftHandRadialDeviation = IntToCStr(0);
} else {
mLeftHandRadialDeviation = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandLDeviation)));
mLeftHandUlnarDeviation = IntToCStr(0);
}
mLeftHipIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipLInc)));
mLeftHipVertical = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipLV)));//lLeftHipIncluded);
mLeftHipHorizontal = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipLH)));
mLeftKneeIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_KneeLInc)));//lLeftKneeIncluded);
mLeftAnkleIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_AnkleLInc)));//lResult.LeftAnkleIncluded()));
mLeftFemoralRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_FemurLRot)));
mLeftLowerlegRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_LowerlegLRot)));
mHeadFlexion = IntToCStr(90 - (Round_Double(skel.getExtraAngle(EA_C1_Flexion))+16));
/*mHeadAxial = IntToCStr(Round_Double(skel.GetAngle(A_C4C7AxialRotation)));
mHeadLateral = IntToCStr(Round_Double(skel.GetAngle(A_C4C7LateralBending)));*/
mHeadAxial = IntToCStr(Round_Double(skel.getExtraAngle(EA_C4C7AxialRotation)) + Round_Double(skel.getExtraAngle(EA_C1C3AxialRotation)));
mHeadLateral = IntToCStr(Round_Double(skel.getExtraAngle(EA_C4C7LateralBending)));
// Add:
//head/torso
mHeadFlexion2 = IntToCStr(90 - (Round_Double(16 + skel.getExtraAngle(EA_C1C3Flexion)+skel.getExtraAngle(EA_C4C7Flexion)+skel.getExtraAngle(EA_C1_Flexion)-180)));
mHeadAxial2 = IntToCStr(Round_Double(skel.getExtraAngle(EA_C1C3AxialRotation)+skel.getExtraAngle(EA_C4C7AxialRotation)));
mHeadLateral2 = IntToCStr(Round_Double(skel.getExtraAngle(EA_C1C3LateralBending)+skel.getExtraAngle(EA_C4C7LateralBending)));
//Upper neck
mNeck1Flexion = IntToCStr(90 - (Round_Double(skel.getExtraAngle(EA_C1C3Flexion))));
mNeck1Rotation = IntToCStr(Round_Double(skel.getExtraAngle(EA_C1C3AxialRotation)));
mNeck1Bending = IntToCStr(Round_Double(skel.getExtraAngle(EA_C1C3LateralBending)));
//Lower neck
mNeck2Flexion = IntToCStr(90 - (Round_Double(skel.getExtraAngle(EA_C4C7Flexion))));
mNeck2Rotation = IntToCStr(Round_Double(skel.getExtraAngle(EA_C4C7AxialRotation)));
mNeck2Bending = IntToCStr(Round_Double(skel.getExtraAngle(EA_C4C7LateralBending)));
/* mAdjustedTrunkFlexion = IntToCStr(Round_Double(skel.getExtraAngle(EA_TrunkFlexion)));//lResult.torsoang));
mAdjustedTrunkRotation = IntToCStr(Round_Double(skel.getExtraAngle(EA_TrunkAxialRotation)));//lResult.trrot));
mAdjustedTrunkBending = IntToCStr(Round_Double(skel.getExtraAngle(EA_TrunkLateralBending)));//skel.GetAngle(A_TrunkLateralBending)));*/
mAdjustedTrunkFlexion = IntToCStr(Round_Double(skel.getExtraAngle(EA_TrunkFlexion)));
mAdjustedTrunkRotation = IntToCStr(Round_Double(skel.getExtraAngle(EA_AdjustedTrunkAxialRotation)));
mAdjustedTrunkBending = IntToCStr(Round_Double(skel.getExtraAngle(EA_AdjustedTrunkLateralBending)));
// mAdjustedTrunkFlexionPelv = IntToCStr(Round_Double(skel.getExtraAngle(EA_AdjustedTrunkFlexion)));
// mAdjustedTrunkRotationPelv = IntToCStr(Round_Double(skel.getExtraAngle(EA_AdjustedTrunkAxialRotation)));
// mAdjustedTrunkBendingPelv = IntToCStr(Round_Double(skel.getExtraAngle(EA_AdjustedTrunkLateralBending)));
mPelvicRotation = IntToCStr((Round_Double(skel.getExtraAngle(EA_PelvisFlexion))));//gPelvicAngle));
//mPelvisLateralBending = IntToCStr((Round_Double(skel.GetAngle(A_PelvisLateralBending))));
mPelvisLateralBending = IntToCStr((Round_Double(skel.getExtraAngle(EA_PelvisLateralBending))));
mRightElbowIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_ElbowRInc)));//lResult.RightElbowIncluded()));
mRightShoulderVert = IntToCStr(Round_Double(skel.getExtraAngle(EA_ShoulderRV)));//lResult.RightShoulderVertical()));
mRightShoulderHorz = IntToCStr(Round_Double(skel.getExtraAngle(EA_ShoulderRH)));//lResult.RightShoulderHorizontal()));
mRightHumeralRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_HumerusRRot)));//lResult.RightHumeralRotation()));
mRightForearmRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_ForearmRRot)));
// C_Hom_Doc* doc = Get_App_Ptr()->Get_Document_Ptr();
// Skeleton &skel = *(doc->GetSkeleton());
double alpha = L5S1_ERECT_TILT - skel.getExtraAngle(EA_PelvisFlexion);
mL5S1ForwardTilt = IntToCStr(Round_Double(90 - alpha));
// 09/17/07 Sayan
// We comment this out as we will be showing Flexion and Extension separately.
// mRightHandFlexion = IntToCStr(int(skel.getExtraAngle(EA_HandRFlexion)));
// Flexion is always negative and Extension is always positive?
if ((int(skel.getExtraAngle(EA_HandRFlexion))) >= 0) {
mRightHandExtension = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandRFlexion)));
mRightHandFlexion = IntToCStr(0);
} else {
mRightHandFlexion = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandRFlexion)));
mRightHandExtension = IntToCStr(0);
};
// 09/17/07 Sayan
// We comment this out as we will be showing ulnar deviation and radial deviation separately.
// mRightHandDeviation = IntToCStr(int(skel.getExtraAngle(EA_HandRDeviation)));
// Radial deviation is always negative and ulnar deviation is always positive?
if ((int(skel.getExtraAngle(EA_HandRDeviation))) >=0) {
mRightHandUlnarDeviation = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandRDeviation)));
mRightHandRadialDeviation = IntToCStr(0);
} else {
mRightHandRadialDeviation = IntToCStr(Round_Double(skel.getExtraAngle(EA_HandRDeviation)));
mRightHandUlnarDeviation = IntToCStr(0);
};
mRightHipIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipRInc)));
mRightHipVertical = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipRV)));//lRightHipIncluded);
mRightHipHorizontal = IntToCStr(Round_Double(skel.getExtraAngle(EA_HipRH)));
mRightKneeIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_KneeRInc)));//lRightKneeIncluded);
mRightAnkleIncluded = IntToCStr(Round_Double(skel.getExtraAngle(EA_AnkleRInc)));//lResult.RightAnkleIncluded()));
mRightFemoralRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_FemurRRot)));
mRightLowerlegRot = IntToCStr(Round_Double(skel.getExtraAngle(EA_LowerlegRRot)));
// write min / max values
// TODO these only change if the user changes the values in the factors dialog (ie almost never)
// we shouldn't have to write them every update. just on init and when they are changed
// TODO the CFloatRangeStatic limits should be changed exactly when these are changed
const Factors& factors = lDocPtr->GetFactors();
mMinHandFlexion = IntToCStr(factors.mROM_HandFlexion[0]);
mMaxHandFlexion = IntToCStr(0); // intentionally zero
mMinHandExtension = IntToCStr(0); // intentionally zero
mMaxHandExtension = IntToCStr(factors.mROM_HandFlexion[1]);
mMinHandUlnarDeviation = IntToCStr(0); // intentionally zero
mMaxHandUlnarDeviation = IntToCStr(factors.mROM_HandDeviation[1]);
mMinHandRadialDeviation = IntToCStr(factors.mROM_HandDeviation[0]);
mMaxHandRadialDeviation = IntToCStr(0); // intentionally zero
mMinForearmRot = IntToCStr(factors.mROM_ForearmRot[0]);
mMaxForearmRot = IntToCStr(factors.mROM_ForearmRot[1]);
mMinElbowIncluded = IntToCStr(factors.mROM_ElbowInc[0]);
mMaxElbowIncluded = IntToCStr(factors.mROM_ElbowInc[1]);
mMinShoulderVert = IntToCStr(factors.mROM_ShoulderV[0]);
mMaxShoulderVert = IntToCStr(factors.mROM_ShoulderV[1]);
mMinShoulderHorz = IntToCStr(factors.mROM_ShoulderH[0]);
mMaxShoulderHorz = IntToCStr(factors.mROM_ShoulderH[1]);
mMinHumeralRot = IntToCStr(factors.mROM_HumerusRot[0]);
mMaxHumeralRot = IntToCStr(factors.mROM_HumerusRot[1]);
mMinHipIncluded = IntToCStr(factors.mROM_HipIncluded[0]);
mMaxHipIncluded = IntToCStr(factors.mROM_HipIncluded[1]);
mMinHipVertical = IntToCStr(factors.mROM_HipV[0]);
mMaxHipVertical = IntToCStr(factors.mROM_HipV[1]);
mMinHipHorizontal = IntToCStr(factors.mROM_HipH[0]);
mMaxHipHorizontal = IntToCStr(factors.mROM_HipH[1]);
mMinFemoralRot = IntToCStr(factors.mROM_FemurRot[0]);
mMaxFemoralRot = IntToCStr(factors.mROM_FemurRot[1]);
mMinLowerlegRot = IntToCStr(factors.mROM_LowerlegRot[0]);
mMaxLowerlegRot = IntToCStr(factors.mROM_LowerlegRot[1]);
mMinKneeIncluded = IntToCStr(factors.mROM_KneeInc[0]);
mMaxKneeIncluded = IntToCStr(factors.mROM_KneeInc[1]);
mMinAnkleIncluded = IntToCStr(factors.mROM_AnkleInc[0]);
mMaxAnkleIncluded = IntToCStr(factors.mROM_AnkleInc[1]);
mMaxHeadFlexion = IntToCStr(90 - (factors.mROM_HeadFlexion[0]+16));
mMinHeadFlexion = IntToCStr(90 - (factors.mROM_HeadFlexion[1]+16));
mMaxNeck1Flexion = IntToCStr(90 - (factors.mROM_UpperNeckFlexion[0]));
mMinNeck1Flexion = IntToCStr(90 - (factors.mROM_UpperNeckFlexion[1]));
mMinNeck1Axial = IntToCStr(factors.mROM_UpperNeckAxialRotation[0]);
mMaxNeck1Axial = IntToCStr(factors.mROM_UpperNeckAxialRotation[1]);
mMinNeck1Lateral = IntToCStr(factors.mROM_UpperNeckLateralBending[0]);
mMaxNeck1Lateral = IntToCStr(factors.mROM_UpperNeckLateralBending[1]);
//head/torso
mMaxHeadFlexion2 = IntToCStr(90 - (16 + factors.mROM_LowerNeckFlexion[0]+factors.mROM_UpperNeckFlexion[0]+factors.mROM_HeadFlexion[0]-180));
mMinHeadFlexion2 = IntToCStr(90 - (16 + factors.mROM_LowerNeckFlexion[1]+factors.mROM_UpperNeckFlexion[1]+factors.mROM_HeadFlexion[1]-180));
mMinHeadAxial2 = IntToCStr(factors.mROM_LowerNeckAxialRotation[0]+factors.mROM_UpperNeckAxialRotation[0]);
mMaxHeadAxial2 = IntToCStr(factors.mROM_LowerNeckAxialRotation[1]+factors.mROM_UpperNeckAxialRotation[1]);
mMinHeadLateral2 = IntToCStr(factors.mROM_LowerNeckLateralBending[0]+factors.mROM_UpperNeckLateralBending[0]);
mMaxHeadLateral2 = IntToCStr(factors.mROM_LowerNeckLateralBending[1]+factors.mROM_UpperNeckLateralBending[1]);
mMaxNeck2Flexion = IntToCStr(90 - factors.mROM_LowerNeckFlexion[0]);
mMinNeck2Flexion = IntToCStr(90 - factors.mROM_LowerNeckFlexion[1]);
mMinNeck2Axial = IntToCStr(factors.mROM_LowerNeckAxialRotation[0]);
mMaxNeck2Axial = IntToCStr(factors.mROM_LowerNeckAxialRotation[1]);
mMinNeck2Lateral = IntToCStr(factors.mROM_LowerNeckLateralBending[0]);
mMaxNeck2Lateral = IntToCStr(factors.mROM_LowerNeckLateralBending[1]);
mMinAdjustedTrunkFlexion = IntToCStr(factors.mROM_AdjustedTrunkFlexion[0]);
mMaxAdjustedTrunkFlexion = IntToCStr(factors.mROM_AdjustedTrunkFlexion[1]);
mMinAdjustedTrunkRotation = IntToCStr(factors.mROM_AdjustedTrunkAxialRotation[0]);
mMaxAdjustedTrunkRotation = IntToCStr(factors.mROM_AdjustedTrunkAxialRotation[1]);
mMinAdjustedTrunkBending = IntToCStr(factors.mROM_AdjustedTrunkLateralBending[0]);
mMaxAdjustedTrunkBending = IntToCStr(factors.mROM_AdjustedTrunkLateralBending[1]);
mMinPelvicRotation = IntToCStr(factors.mROM_PelvisFlexion[0]);
mMaxPelvicRotation = IntToCStr(factors.mROM_PelvisFlexion[1]);
mMinPelvisLateralBending = IntToCStr(factors.mROM_PelvisLateralBending[0]);
mMaxPelvisLateralBending = IntToCStr(factors.mROM_PelvisLateralBending[1]);
mMinL5S1ForwardTilt = IntToCStr(0); // TODO
mMaxL5S1ForwardTilt = IntToCStr(0); // TODO
// TODO adding red text on limit violation
mLeftHandFlexionCtrl.SetMin(factors.mROM_HandFlexion[0]);
mLeftHandFlexionCtrl.SetMax(0); // intentionally zero
mRightHandFlexionCtrl.SetMin(factors.mROM_HandFlexion[0]);
mRightHandFlexionCtrl.SetMax(0); // intentionally zero
mLeftHandExtensionCtrl.SetMin(0); // intentionally zero
mLeftHandExtensionCtrl.SetMax(factors.mROM_HandFlexion[1]);
mRightHandExtensionCtrl.SetMin(0); // intentionally zero
mRightHandExtensionCtrl.SetMax(factors.mROM_HandFlexion[1]);
mLeftHandUlnarDeviationCtrl.SetMin(0); // intentionally zero
mLeftHandUlnarDeviationCtrl.SetMax(factors.mROM_HandDeviation[1]);
mRightHandUlnarDeviationCtrl.SetMin(0); // intentionally zero
mRightHandUlnarDeviationCtrl.SetMax(factors.mROM_HandDeviation[1]);
mLeftHandRadialDeviationCtrl.SetMin(factors.mROM_HandDeviation[0]);
mLeftHandRadialDeviationCtrl.SetMax(0); // intentionally zero
mRightHandRadialDeviationCtrl.SetMin(factors.mROM_HandDeviation[0]);
mRightHandRadialDeviationCtrl.SetMax(0);
mLeftForearmRotCtrl.SetMin(factors.mROM_ForearmRot[0]);
mLeftForearmRotCtrl.SetMax(factors.mROM_ForearmRot[1]);
mRightForearmRotCtrl.SetMin(factors.mROM_ForearmRot[0]);
mRightForearmRotCtrl.SetMax(factors.mROM_ForearmRot[1]);
mLeftElbowIncludedCtrl.SetMin(factors.mROM_ElbowInc[0]);
mLeftElbowIncludedCtrl.SetMax(factors.mROM_ElbowInc[1]);
mRightElbowIncludedCtrl.SetMin(factors.mROM_ElbowInc[0]);
mRightElbowIncludedCtrl.SetMax(factors.mROM_ElbowInc[1]);
mLeftShoulderVertCtrl.SetMin(factors.mROM_ShoulderV[0]);
mLeftShoulderVertCtrl.SetMax(factors.mROM_ShoulderV[1]);
mLeftShoulderHorzCtrl.SetMin(factors.mROM_ShoulderH[0]);
mLeftShoulderHorzCtrl.SetMax(factors.mROM_ShoulderH[1]);
mRightShoulderVertCtrl.SetMin(factors.mROM_ShoulderV[0]);
mRightShoulderVertCtrl.SetMax(factors.mROM_ShoulderV[1]);
mRightShoulderHorzCtrl.SetMin(factors.mROM_ShoulderH[0]);
mRightShoulderHorzCtrl.SetMax(factors.mROM_ShoulderH[1]);
mLeftHumeralRotCtrl.SetMin(factors.mROM_HumerusRot[0]);
mLeftHumeralRotCtrl.SetMax(factors.mROM_HumerusRot[1]);
mRightHumeralRotCtrl.SetMin(factors.mROM_HumerusRot[0]);
mRightHumeralRotCtrl.SetMax(factors.mROM_HumerusRot[1]);
mLeftHipIncludedCtrl.SetMin(factors.mROM_HipIncluded[0]);
mLeftHipIncludedCtrl.SetMax(factors.mROM_HipIncluded[1]);
mLeftHipVerticalCtrl.SetMin(factors.mROM_HipV[0]);
mLeftHipVerticalCtrl.SetMax(factors.mROM_HipV[1]);
mLeftHipHorizontalCtrl.SetMin(factors.mROM_HipH[0]);
mLeftHipHorizontalCtrl.SetMax(factors.mROM_HipH[1]);
mRightHipIncludedCtrl.SetMin(factors.mROM_HipIncluded[0]);
mRightHipIncludedCtrl.SetMax(factors.mROM_HipIncluded[1]);
mRightHipVerticalCtrl.SetMin(factors.mROM_HipV[0]);
mRightHipVerticalCtrl.SetMax(factors.mROM_HipV[1]);
mRightHipHorizontalCtrl.SetMin(factors.mROM_HipH[0]);
mRightHipHorizontalCtrl.SetMax(factors.mROM_HipH[1]);
mLeftFemoralRotCtrl.SetMin(factors.mROM_FemurRot[0]);
mLeftFemoralRotCtrl.SetMax(factors.mROM_FemurRot[1]);
mRightFemoralRotCtrl.SetMin(factors.mROM_FemurRot[0]);
mRightFemoralRotCtrl.SetMax(factors.mROM_FemurRot[1]);
mLeftLowerlegRotCtrl.SetMin(factors.mROM_LowerlegRot[0]);
mLeftLowerlegRotCtrl.SetMax(factors.mROM_LowerlegRot[1]);
mRightLowerlegRotCtrl.SetMin(factors.mROM_LowerlegRot[0]);
mRightLowerlegRotCtrl.SetMax(factors.mROM_LowerlegRot[1]);
mLeftKneeIncludedCtrl.SetMin(factors.mROM_KneeInc[0]);
mLeftKneeIncludedCtrl.SetMax(factors.mROM_KneeInc[1]);
mLeftAnkleIncludedCtrl.SetMin(factors.mROM_AnkleInc[0]);
mLeftAnkleIncludedCtrl.SetMax(factors.mROM_AnkleInc[1]);
mRightKneeIncludedCtrl.SetMin(factors.mROM_KneeInc[0]);
mRightKneeIncludedCtrl.SetMax(factors.mROM_KneeInc[1]);
mRightAnkleIncludedCtrl.SetMin(factors.mROM_AnkleInc[0]);
mRightAnkleIncludedCtrl.SetMax(factors.mROM_AnkleInc[1]);
mHeadFlexionCtrl2.SetMax(90 - (16 + factors.mROM_LowerNeckFlexion[0]+factors.mROM_UpperNeckFlexion[0]+factors.mROM_HeadFlexion[0]-180));
mHeadFlexionCtrl2.SetMin(90 - (16 + factors.mROM_LowerNeckFlexion[1]+factors.mROM_UpperNeckFlexion[1]+factors.mROM_HeadFlexion[1]-180));
mHeadAxialCtrl2.SetMin(factors.mROM_LowerNeckAxialRotation[0]+factors.mROM_UpperNeckAxialRotation[0]);
mHeadAxialCtrl2.SetMax(factors.mROM_LowerNeckAxialRotation[1]+factors.mROM_UpperNeckAxialRotation[1]);
mHeadLateralCtrl2.SetMin(factors.mROM_LowerNeckLateralBending[0]+factors.mROM_UpperNeckLateralBending[0]);
mHeadLateralCtrl2.SetMax(factors.mROM_LowerNeckLateralBending[1]+factors.mROM_UpperNeckLateralBending[1]);
mHeadFlexionCtrl.SetMax(90 - (16 + factors.mROM_HeadFlexion[0]));
mHeadFlexionCtrl.SetMin(90 - (16 + factors.mROM_HeadFlexion[1]));
mAdjustedNeck1FlexionCtrl.SetMax(90 - factors.mROM_UpperNeckFlexion[0]);
mAdjustedNeck1FlexionCtrl.SetMin(90 - factors.mROM_UpperNeckFlexion[1]);
mAdjustedNeck1RotationCtrl.SetMin(factors.mROM_UpperNeckAxialRotation[0]);
mAdjustedNeck1RotationCtrl.SetMax(factors.mROM_UpperNeckAxialRotation[1]);
mAdjustedNeck1BendingCtrl.SetMin(factors.mROM_UpperNeckLateralBending[0]);
mAdjustedNeck1BendingCtrl.SetMax(factors.mROM_UpperNeckLateralBending[1]);
mAdjustedNeck2FlexionCtrl.SetMax(90 - factors.mROM_LowerNeckFlexion[0]);
mAdjustedNeck2FlexionCtrl.SetMin(90 - factors.mROM_LowerNeckFlexion[1]);
mAdjustedNeck2RotationCtrl.SetMin(factors.mROM_LowerNeckAxialRotation[0]);
mAdjustedNeck2RotationCtrl.SetMax(factors.mROM_LowerNeckAxialRotation[1]);
mAdjustedNeck2BendingCtrl.SetMin(factors.mROM_LowerNeckLateralBending[0]);
mAdjustedNeck2BendingCtrl.SetMax(factors.mROM_LowerNeckLateralBending[1]);
mAdjustedTrunkFlexionCtrl.SetMin(factors.mROM_AdjustedTrunkFlexion[0]);
mAdjustedTrunkFlexionCtrl.SetMax(factors.mROM_AdjustedTrunkFlexion[1]);
mAdjustedTrunkRotationCtrl.SetMin(factors.mROM_AdjustedTrunkAxialRotation[0]);
mAdjustedTrunkRotationCtrl.SetMax(factors.mROM_AdjustedTrunkAxialRotation[1]);
mAdjustedTrunkBendingCtrl.SetMin(factors.mROM_AdjustedTrunkLateralBending[0]);
mAdjustedTrunkBendingCtrl.SetMax(factors.mROM_AdjustedTrunkLateralBending[1]);
mPelvicRotationCtrl.SetMin(factors.mROM_PelvisFlexion[0]);
mPelvicRotationCtrl.SetMax(factors.mROM_PelvisFlexion[1]);
mPelvisLateralBendingCtrl.SetMin(factors.mROM_PelvisLateralBending[0]);
mPelvisLateralBendingCtrl.SetMax(factors.mROM_PelvisLateralBending[1]);
// TODO
//mL5S1ForwardTiltCtrl.SetMin(factors.mROM_PelvisFlexion[0]);
//mL5S1ForwardTiltCtrl.SetMax(factors.mROM_PelvisFlexion[1]);
UpdateUnits();
// TODO
// debugging oblique view
mLeftAnkleBending = DblToCStr(skel.getLAnkleLateralBending(), 4, 4);
mRightAnkleBending = DblToCStr(skel.getRAnkleLateralBending(), 4, 4);
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData(FALSE);
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
void ReportJointForces::OnUpdate(CView* aSenderPtr,LPARAM aHint,CObject* aHintPtr)
{
C_Hom_Doc* lDocPtr = (C_Hom_Doc*)GetDocument();
//Analysis& lResults = lDocPtr->getResultsRef();
// Determine which data members are relevant to the current posture
BOOL enableHips = TRUE;
BOOL enableFront = TRUE;
BOOL enableBack = TRUE;
if(lDocPtr->getPosition() == P_Standing)
enableHips = FALSE;
if((lDocPtr->getPosition() == P_Standing) || !lDocPtr->hasFrontSeatPanSupport()) // Not seated or front not supported
enableFront = FALSE;
if((lDocPtr->getPosition() == P_Standing) || !lDocPtr->hasSeatBackRest()) // Not seated or no seat back
enableBack = FALSE;
mForceUnits = CString("Force (") + lDocPtr->ForceUnits() + ") -- Due to Body Weight and External Applied Loads";
// Retrieve joint force analysis results
Vector3 forces[NUM_JOINTS];
lDocPtr->GetSkeleton()->getNetForces(forces);
for(int i = 0; i < NUM_JOINTS; ++i) { // *****34 must be replaced by NUM_JOINTS once the locations of hand joints are being handled properly*****
if(jointToMember[i]) {
for(int j = 0; j < 3; ++j) {
jointToMember[i][j].Format("%.1f", forces[i] [j]);
if(jointToMember[i][j] == "-0.0")
jointToMember[i][j].Format("0.0");
}
}
}
Skeleton* skel = lDocPtr->GetSkeleton();
// L4L5 forces
const SpinalForces_s& spinalForces = skel->getSpinalForces();
mL4L5Force[0].Format("%.1f", spinalForces.globalL4L5NoAbdom[0]);
mL4L5Force[1].Format("%.1f", spinalForces.globalL4L5NoAbdom[1]);
mL4L5Force[2].Format("%.1f", spinalForces.globalL4L5NoAbdom[2]);
// Set any irrelevant data to dashes
if(!enableBack) {
mSeatBack[1] = mSeatBack[2] = "---";
} else {
Vector3 seatBackForce = skel->getSeatBackForce();
for(int i = 0; i < 3; i++) {
// force applied to the seat back is negative of the value we calculated,
// which was the force applied to the back by the seat back
mSeatBack[i].Format("%.1f", -seatBackForce[i]);
if(mSeatBack[i] == "-0.0")
mSeatBack[i].Format("0.0");
}
}
if(!enableHips) {
mLeftIT[0] = mLeftIT[1] = mLeftIT[2] = "---";
mRightIT[0] = mRightIT[1] = mRightIT[2] = "---";
}
if(!enableFront) {
mSeatFrontRight[0] = mSeatFrontRight[1] = mSeatFrontRight[2] = "---";
mSeatFrontLeft[0] = mSeatFrontLeft[1] = mSeatFrontLeft[2] = "---";
} else {
Vector3 frontRightForce = skel->getRightSeatFrontForce();
Vector3 frontLeftForce = skel->getLeftSeatFrontForce();
for(int i = 0; i < 3; i++) {
mSeatFrontRight[i].Format("%.1f",frontRightForce[i]);
if(mSeatFrontRight[i] == "-0.0")
mSeatFrontRight[i].Format("0.0");
mSeatFrontLeft[i].Format("%.1f",frontLeftForce[i]);
if(mSeatFrontLeft[i] == "-0.0")
mSeatFrontLeft[i] = "0.0";
}
}
// Gray-out any irrelevent data
this->GetDlgItem(IDC_LeftITX)->EnableWindow(enableHips);
this->GetDlgItem(IDC_LeftITY)->EnableWindow(enableHips);
this->GetDlgItem(IDC_LeftITZ)->EnableWindow(enableHips);
this->GetDlgItem(IDC_RightITX)->EnableWindow(enableHips);
this->GetDlgItem(IDC_RightITY)->EnableWindow(enableHips);
this->GetDlgItem(IDC_RightITZ)->EnableWindow(enableHips);
this->GetDlgItem(IDC_SeatFrontRightX)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatFrontRightY)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatFrontRightZ)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatFrontLeftX)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatFrontLeftY)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatFrontLeftZ)->EnableWindow(enableFront);
this->GetDlgItem(IDC_SeatBackY)->EnableWindow(enableBack);
this->GetDlgItem(IDC_SeatBackZ)->EnableWindow(enableBack);
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData(FALSE);
UpdateUnits();
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
void ReportAnalysisSummary::OnUpdate(CView* aSenderPtr, LPARAM aHint, CObject* aHintPtr)
{
C_Hom_Doc* lDocPtr = static_cast<C_Hom_Doc*>(GetDocument());
//Analysis& lResults = lDocPtr->getResultsRef();
Skeleton* skel = lDocPtr->GetSkeleton();
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
// Retrieve analysis summary results and gender-specific capability limits
const AnalysisSummaryData_s& analysis_summary = skel->getAnalysisSummary();
AnalysisSummaryLimits limits = skel->getAnalysisSummaryLimits();
const BalanceData_s& balance = skel->getBalanceData();
//Percent Capables
mWristBar.SetRange(0, 100);
mWristBar.SetPos(int(analysis_summary.WristMinPercentile));
mWristValue = (char*)String_Cast(Round_Double(analysis_summary.WristMinPercentile,0),3);
mWristBar.SetMaximum(100);
mWristBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mElbowBar.SetRange(0, 100);
mElbowBar.SetPos(int(analysis_summary.ElbowMinPercentile));
mElbowValue = (char*)String_Cast(Round_Double(analysis_summary.ElbowMinPercentile,0),3);
mElbowBar.SetMaximum(100);
mElbowBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mShoulderBar.SetRange(0, 100);
mShoulderBar.SetPos(int(analysis_summary.ShoulderMinPercentile));
mShoulderValue = (char*)String_Cast(Round_Double(analysis_summary.ShoulderMinPercentile,0),3);
mShoulderBar.SetMaximum(100);
mShoulderBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mTorsoBar.SetRange(0, 100);
mTorsoBar.SetPos(int(analysis_summary.TorsoMinPercentile));
mTorsoValue = (char*)String_Cast(Round_Double(analysis_summary.TorsoMinPercentile,0),3);
mTorsoBar.SetMaximum(100);
mTorsoBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mHipBar.SetRange(0, 100);
mHipBar.SetPos(int(analysis_summary.HipMinPercentile));
mHipValue = (char*)String_Cast(Round_Double(analysis_summary.HipMinPercentile,0),3);
mHipBar.SetMaximum(100);
mHipBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mKneeBar.SetRange(0, 100);
mKneeBar.SetPos(int(analysis_summary.KneeMinPercentile));
mKneeValue = (char*)String_Cast(Round_Double(analysis_summary.KneeMinPercentile,0),3);
mKneeBar.SetMaximum(100);
mKneeBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
mAnkleBar.SetRange(0, 100);
mAnkleBar.SetPos(int(analysis_summary.AnkleMinPercentile));
mAnkleValue = (char*)String_Cast(Round_Double(analysis_summary.AnkleMinPercentile,0),3);
mAnkleBar.SetMaximum(100);
mAnkleBar.SetAllRanges(0, limits.SUL, limits.SUL, limits.SDL, limits.SDL, 100);
//--- Disc Compression (3D)---
//Update the scale to show correct values in the current unit system
//Force temp;
//temp.Value(analysis_summary.L4L5Compression, MetricCns);
if (lDocPtr->Is_Metric())
{
GetDlgItem(IDC_CompressionBox)->SetWindowText("3D Low back Compression (N):");
mCompressionZeroLbl = "0";
mCompressionSDLLbl = "3425";
mCompressionSULLbl = "6361";
mCompressionMaxLbl = "8335";
}
else
{
GetDlgItem(IDC_CompressionBox)->SetWindowText("3D Low back Compression (lb):");
mCompressionZeroLbl = "0";
mCompressionSDLLbl = "770";
mCompressionSULLbl = "1430";
mCompressionMaxLbl = "1874";
}
mL4L5DiscValue.Format("%.1f",analysis_summary.L4L5Compression);//temp.ValueText();
// Get the English form of the force to test UL/
mL4L5DiscBar.SetPos(analysis_summary.L4L5CompressionPct);
mL4L5DiscBar.SetMaximum(100);
//SDL == 770 lb, SUL == 1430 lb
//(BS) In Hom_doc.cpp, mL4L5CompressionMax is defined as 8335.0N. This is the maximum
//range of the slider, and the DL and UL ranges are set as percentages of this
int L4L5_SDL = 770;
int L4L5_SUL = 1430;
int compressionMax = L4L5_COMPRESSION_MAX*U_NEWTONS_LBF;
mL4L5DiscBar.SetOKRange(0, (int)((L4L5_SDL*100)/compressionMax) - 1);
mL4L5DiscBar.SetDLRange((int)((L4L5_SDL*100)/compressionMax) - 1, (int)((L4L5_SUL*100)/compressionMax) + 1);
mL4L5DiscBar.SetULRange((int)((L4L5_SUL*100)/compressionMax) + 1, 100);
//--- Feet ---
GetDlgItem(IDC_FrictionValue)->EnableWindow(TRUE);
mLeftPercentLoadValue.Format("%d%%",Round_Double(balance.LeftPctLoad));
mRightPercentLoadValue.Format("%d%%",Round_Double(balance.RightPctLoad));
mFrictionValue = (char*)String_Cast(Round_Double(analysis_summary.frcoef, 2), 2);
//mCGBalanceValue = lResults.getBalanceString((int)balance.PWBCGBal);
if(balance.BalanceStatus == BS_Acceptable)
mCGBalanceValue = "Acceptable";
else if(balance.BalanceStatus == BS_Critical)
mCGBalanceValue = "Critical";
else
mCGBalanceValue = "Unacceptable";
//If seated, we don't want to show friction or leg loads
if(lDocPtr->getPosition() == P_Sitting)
mLeftPercentLoadValue = mRightPercentLoadValue = mFrictionValue = "---";
//If the COF wasn't calculated because there are no X and Y forces or because the
//body is out of balance, gray out the COF.
if(analysis_summary.FrictionNotCalculated || balance.BalanceStatus == BS_Unacceptable)
//if(lResults.COFNotCalculated || balance.BalanceStatus == BS_Unacceptable)//(lResults.PWBCGbal == 0))
{
mFrictionValue = "---";
GetDlgItem(IDC_FrictionValue)->EnableWindow(FALSE);
}
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
bool standing = lDocPtr->getPosition() == P_Standing;
if(standing) {
glBasic = &glBalanceStanding;
} else {
glBasic = &glBalanceSitting;
}
glBasic->onDraw();
//Invalidate(false);
UpdateData(FALSE);
UpdateUnits();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
return;
}
void ReportSagittal::OnUpdate(CView* aSenderPtr,LPARAM aHint,CObject* aHintPtr)
{
C_Hom_Doc *lDocPtr = (C_Hom_Doc*)GetDocument();
//Analysis &lResults = lDocPtr->getResultsRef();
// Fill in measurement units text
// Force temp(0.0F,0);
mCompressionLabel = CString("") + "Total Compression (" + lDocPtr->ForceUnits() + "):";
mShearLabel = CString("") + "Total Shear (" + lDocPtr->ForceUnits() + "):";
// Get sagittal low back analysis results
//LowBackSagittalData sagittal;
//lResults.getLowBackSagittal(&sagittal);
const LowBackSagittalData_s& sagittal = lDocPtr->GetSkeleton()->getLowBackSagittalData();
// Write results to the form controls, converting to the desired system of units in the process
const int NUM_DATUM = 12;
CString* reported[] = {&mTotalCompression,&mTotalCompressionSD,&mErectorSpinae,&mErectorSpinaeSD,&mRectusAbdominus,
&mRectusAbdominusSD,&mAbdominal,&mCompressionHandLoads,&mCompressionBodyWeight,&mTotalShear,
&mSagittal,&mFrontal};
double data[] = {sagittal.cmpTotal, sagittal.cmpTotalSD, sagittal.cmpSpinae, sagittal.cmpSpinaeSD, sagittal.cmpAbdominus,
sagittal.cmpAbdominusSD, sagittal.cmpAbdominal, sagittal.cmpHandLoads, sagittal.cmpUpperBody, sagittal.shrTotal,
sagittal.shrSagittal, sagittal.shrFrontal};
for(int i = 0; i < NUM_DATUM; ++i)
{
(*(reported[i])).Format("%.0f", data[i]);
//temp.Value(*((double*)&sagittal + i), MetricCns); // + 2 to pass by total compression / stddev
//temp.Value(data[i], MetricCns);
//*(reported[i]) = temp.ValueText();
}
mStrain.Format("%.0f",sagittal.ligamentStrain);
// Add +/- to the standard deviations
mTotalCompressionSD = "+/- " + mTotalCompressionSD;
mErectorSpinaeSD = "+/- " + mErectorSpinaeSD;
mRectusAbdominusSD = "+/- " + mRectusAbdominusSD;
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData( FALSE );
UpdateUnits();
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
void ReportLowBack::OnUpdate(CView* aSenderPtr,LPARAM aHint,CObject* aHintPtr)
{
C_Hom_Doc* lDocPtr = (C_Hom_Doc*)GetDocument();
//Analysis &lResults = lDocPtr->getResultsRef();
// Fill in measurement units text
//Length templ(0.0F,1);
//Force tempf(0.0F,0);
mArmsLabel = CString("") + "Mom. Arms (" + lDocPtr->LengthUnits() + ")";
mForcesLabel = CString("") + "Forces (" + lDocPtr->ForceUnits() + ")";
mCompressionLabel = CString("") + "Compression (" + lDocPtr->ForceUnits() + ")";
mShearLabel = CString("") + "Shear (" + lDocPtr->ForceUnits() + ")";
// Get 3d low back analysis results
//LowBack3DData lowback;
//lResults.getLowBack3D(&lowback);
const LowBack3DData_s& lowBack = lDocPtr->GetSkeleton()->getLowBack3DData();
// Report lowback forces
//CString *reportedForces[] = {mLESForce,mRESForce,mLRAForce,mRRAForce,mLIOForce,mRIOForce,mLEOForce,mREOForce,mLLDForce,mRLDForce};
const double* forceData[] = {lowBack.Resultant, lowBack.Shear, lowBack.XForce, lowBack.YForce, lowBack.ZForce };
for(int i = 0; i < NUM_BACK_MUSCLES; ++i) {
for(int j = 0; j < 5; ++j) {
//tempf.Value(*((double*)&lowback + 5*i + j), MetricCns);
//reportedForces[i][j] = tempf.ValueText();
// Sayan 07/13/07
//
// Cleaned this up as unit conversion is now handled elsewhere
muscleToMember[i][j].Format("%.0f",forceData[j][i]);
}
}
// Report lowback moment arms
//CString *reportedArms[] = {mLESArm,mRESArm,mLRAArm,mRRAArm,mLIOArm,mRIOArm,mLEOArm,mREOArm,mLLDArm,mRLDArm};
const double* armData[] = {lowBack.XArm, lowBack.YArm};
for(int i = 0; i < NUM_BACK_MUSCLES; ++i) {
for(int j = 0; j < 2; ++j)
{
//templ.Value(*((double*)&lowback + 50 + 2*i + j), MetricCns);
//reportedArms[i][j] = templ.ValueText();
// Sayan 07/13/07
//
// Cleaned this up as unit conversion is now handled elsewhere
armToMember[i][j].Format("%.1f",fabs(armData[j][i]));
}
}
// Report L4L5 disc compression and shear
/*CString *reportedL4L5[] = {&mDiscCompression, &mDiscShear, &mDiscAntPostShear, &mDiscLateralShear};
for(int i = 0; i < 4; ++i)
{
tempf.Value(*((double*)&lowback + 70 + i), MetricCns);
*(reportedL4L5[i]) = tempf.ValueText();
}*/
// Sayan 07/13/07
//
// Cleaned this up as unit conversion is now handled elsewhere
UpdateUnits();
mDiscCompression.Format("%.0f",lowBack.totalL4L5Compression);
mDiscShear.Format("%.0f",lowBack.totalL4L5Shear);
mDiscAntPostShear.Format("%.0f",lowBack.anteriorL4L5Shear);
mDiscLateralShear.Format("%.0f",lowBack.lateralL4L5Shear);
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData(FALSE);
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
std::vector<IUnit*> CSpringGame::GetUnits() {
UpdateUnits();
return teamUnits;
}
std::vector<IUnit*> CSpringGame::GetFriendlies() {
UpdateUnits();
return friendlyUnits;
}
bool CSpringGame::HasFriendlies() {
UpdateUnits();
return !friendlyUnits.empty();
}
std::vector<IUnit*> CSpringGame::GetEnemies() {
UpdateUnits();
return enemyUnits;
}
bool CSpringGame::HasEnemies() {
UpdateUnits();
return !enemyUnits.empty();
}
void ReportTaskInputSummary::OnUpdate( CView* aSenderPtr,
LPARAM aHint,
CObject* aHintPtr )
{
C_Hom_Doc* lDocPtr = static_cast <C_Hom_Doc*> (GetDocument());
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
JointAngles docJointAngles;
//lSkeleton.GetAngles(lSkeleton.getCurrentFrame(),docJointAngles);
docJointAngles = lSkeleton.GetAngles();
Length lLocX( 0, 1 );
Length lLocY( 0, 1 );
Length lLocZ( 0, 1 );
mLeftFootHori = IntToCStr( docJointAngles[A_FootLH] );
mLeftFootVert = IntToCStr( docJointAngles[A_FootLV] );
mRightFootHori = IntToCStr( docJointAngles[A_FootRH] );
mRightFootVert = IntToCStr( docJointAngles[A_FootRV] );
mLeftWristHori = IntToCStr( docJointAngles[A_HandLH] );
mLeftWristVert = IntToCStr( docJointAngles[A_HandLV] );
mLeftWristRot = IntToCStr( docJointAngles[A_HandLRot] );
mRightWristHori = IntToCStr( docJointAngles[A_HandRH] );
mRightWristVert = IntToCStr( docJointAngles[A_HandRV] );
mRightWristRot = IntToCStr( docJointAngles[A_HandRRot] );
mLeftForeArmHori = IntToCStr( docJointAngles[A_ForearmLH] );
mLeftForeArmVert = IntToCStr( docJointAngles[A_ForearmLV] );
mLeftUpperArmHori = IntToCStr( docJointAngles[A_UpperarmLH] );
mLeftUpperArmVert = IntToCStr( docJointAngles[A_UpperarmLV] );
mLeftUpperlegHori = IntToCStr( docJointAngles[A_UpperlegLH] );
mLeftUpperLegVert = IntToCStr( docJointAngles[A_UpperlegLV] );
mLeftLowerlegHori = IntToCStr( docJointAngles[A_LowerlegLH] );
mLeftLowerLegVert = IntToCStr( docJointAngles[A_LowerlegLV] );
mRightForeArmHori = IntToCStr( docJointAngles[A_ForearmRH] );
mRightForeArmVert = IntToCStr( docJointAngles[A_ForearmRV] );
mRightUpperArmHori = IntToCStr( docJointAngles[A_UpperarmRH] );
mRightUpperArmVert = IntToCStr( docJointAngles[A_UpperarmRV] );
mRightUpperlegHori = IntToCStr( docJointAngles[A_UpperlegRH] );
mRightUpperLegVert = IntToCStr( docJointAngles[A_UpperlegRV] );
mRightLowerlegHori = IntToCStr( docJointAngles[A_LowerlegRH] );
mRightLowerLegVert = IntToCStr( docJointAngles[A_LowerlegRV] );
mLeftClavicleHori = IntToCStr( docJointAngles[A_ClavicleLH] );
mLeftClavicleVert = IntToCStr( docJointAngles[A_ClavicleLV] );
mRightClavicleHori = IntToCStr( docJointAngles[A_ClavicleRH] );
mRightClavicleVert = IntToCStr( docJointAngles[A_ClavicleRV] );
mTrunkBending = IntToCStr( docJointAngles[A_TrunkLateralBending] );
mTrunkFlexion = IntToCStr( docJointAngles[A_TrunkFlexion] );
mTrunkRotation = IntToCStr( docJointAngles[A_TrunkAxialRotation] );
mPelvicTilt = IntToCStr( docJointAngles[A_PelvisLateralBending] );
mPelvicAxial = IntToCStr( docJointAngles[A_PelvisAxialRotation] );
mHeadFlexion = IntToCStr( docJointAngles[A_C4C7Flexion] ); // local angle
C_Hom_Doc* mDocPtr = (C_Hom_Doc*)GetDocument();
double angles[NUM_EXTRA_ANGLES];
mDocPtr->GetSkeleton()->getExtraAngles(angles);
mHeadFlexion = IntToCStr(mDocPtr->GetSkeleton()->GetAngles()[A_TrunkFlexion] - (270 - (angles[EA_C4C7Flexion]+16 + angles[EA_C1C3Flexion] + angles[EA_C1_Flexion]))); // global angle
//mHeadRotation = IntToCStr( docJointAngles[A_C4C7AxialRotation] ); // local
mHeadRotation = IntToCStr(angles[EA_C1C3AxialRotation] + angles[EA_C4C7AxialRotation]); // gloabl
//mHeadBending = IntToCStr( docJointAngles[A_C4C7LateralBending] ); // local
mHeadBending = IntToCStr(angles[EA_C1C3AxialRotation] + angles[EA_C4C7AxialRotation]); // global
int lPrecision = 3;
int lRound = 0;
mLocationLabel = CString("") + "Location(" + lLocX.UnitsText() + "):";
//bool standing = !(lDocPtr->getPositioning() & 1);
bool standing = lDocPtr->getPosition() == P_Standing;
// hand locations
/*lSkeleton.ReportPoint(JT_LHAND, lLocX, lLocY, lLocZ, standing);
mLeftHandLocHori = lLocY.ValueText();
mLeftHandLocLat = lLocX.ValueText();
mLeftHandLocVert = lLocZ.ValueText();*/
Vector3 lhand = lSkeleton.getJoint(JT_LHAND) - lDocPtr->getOffset(&lSkeleton);
mLeftHandLocHori.Format("%.1f", lhand[1]);
mLeftHandLocLat.Format("%.1f", lhand[0]);
mLeftHandLocVert.Format("%.1f", lhand[2]);
/*lSkeleton.ReportPoint(JT_RHAND, lLocX, lLocY, lLocZ, standing);
mRightHandLocHori = lLocY.ValueText();
mRightHandLocLat = lLocX.ValueText();
mRightHandLocVert = lLocZ.ValueText();*/
Vector3 rhand = lSkeleton.getJoint(JT_RHAND) - lDocPtr->getOffset(&lSkeleton);
mRightHandLocHori.Format("%.1f", rhand[1]);
mRightHandLocLat.Format("%.1f", rhand[0]);
mRightHandLocVert.Format("%.1f", rhand[2]);
Force tempForce(0,1);
mForceUnits = CString("") + "(" + tempForce.UnitsText() + ")";
mLeftForceMagUnits = CString("") + "Mag" + mForceUnits;
mRightForceMagUnits = CString("") + "Mag" + mForceUnits;
// Sayan 07/16/07
//
// We do the unit conversions a lot more cleanly than before, because
// unit conversions are now handled elsewhere in the code in one clean
// routine.
// hand force magnitudes
// tempForce.Value(lSkeleton.getExtForce(JT_LHAND).length(),MetricCns);
// mLeftHandForceMag = tempForce.ValueText();
// tempForce.Value(lSkeleton.getExtForce(JT_RHAND).length(),MetricCns);
// mRightHandForceMag = tempForce.ValueText();
mLeftHandForceMag.Format("%.1f",lSkeleton.getExtForce(JT_LHAND).length());
// Sayan 07/16/07
//
// Should the line commented out below be there? Not completely sure.
// hingeToMember[i][0].Format("%.0f", strength.Moment[i]);
mRightHandForceMag.Format("%.1f",lSkeleton.getExtForce(JT_RHAND).length());
// hand force angles
double rv,rh,lv,lh;
Vector3 LHandForce = lSkeleton.getExtForce(JT_LHAND);
Vector3 RHandForce = lSkeleton.getExtForce(JT_RHAND);
// convert force vectors to spherical angles
if(LHandForce == Vector3(0,0,0)) lv = -90;
else lv = 90.0 - degreesBetween(LHandForce,Vector3(0,0,1));
if(RHandForce == Vector3(0,0,0)) rv = -90;
else rv = 90.0 - degreesBetween(RHandForce,Vector3(0,0,1));
RHandForce[2] = 0.0;
if(RHandForce == Vector3(0,0,0)) rh = 90.0;
else rh = degreesBetween(RHandForce,Vector3(1,0,0));
if(RHandForce[1] < 0) rh *= -1;
LHandForce[2] = 0.0;
if(LHandForce == Vector3(0,0,0)) lh = 90.0;
else lh = degreesBetween(LHandForce,Vector3(1,0,0));
if(LHandForce[1] < 0) lh *= -1;
mLeftHandForceHori = IntToCStr(int(lh));
mLeftHandForceVert = IntToCStr(int(lv));
mRightHandForceHori = IntToCStr(int(rh));
mRightHandForceVert = IntToCStr(int(rv));
mHandOrientation = lDocPtr->getTask().HandOrientationText();
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData( FALSE );
UpdateDynamicSummary();
UpdateUnits();
UpdateData( FALSE );
this->RedrawWindow(NULL, NULL, RDW_UPDATENOW | RDW_ALLCHILDREN);
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
void ReportJointMoments::OnUpdate(CView *aSenderPtr,LPARAM aHint,CObject *aHintPtr)
{
C_Hom_Doc *lDocPtr = (C_Hom_Doc*)GetDocument();
// Fill in measurement units text
mMomentUnits = CString("Moments ") + "(" + lDocPtr->TorqueUnits() + ") -- Due to Body Weight and External Applied Loads";
// Retrieve joint moment analysis results
Vector3 moments[NUM_JOINTS];
lDocPtr->GetSkeleton()->getNetMoments(moments);
// Write results to the form controls
for(int i = 0; i < NUM_JOINTS; ++i) { // *****34 must be replaced by NUM_JOINTS once the locations of hand joints are being handled properly*****
if(jointToMember[i]) {
for(int j = 0; j < 3; ++j)
{
jointToMember[i][j].Format("%.1f",(moments [i][j]));
if(jointToMember[i][j] == "-0.0") {
jointToMember[i][j].Format("0");
}
}
}
}
Skeleton* skel = lDocPtr->GetSkeleton();
// L4L5 forces
const SpinalMoments_s& spinalMoments = skel->getSpinalMoments();
mL4L5Mom[0].Format("%.1f", spinalMoments.globalL4L5NoAbdom[0]);
mL4L5Mom[1].Format("%.1f", spinalMoments.globalL4L5NoAbdom[1]);
mL4L5Mom[2].Format("%.1f", spinalMoments.globalL4L5NoAbdom[2]);
// Set any irrelevant values to dashes
BOOL enableIT = lDocPtr->getPosition() == P_Sitting;
if(!enableIT)
{
mLeftITMom[0] = mLeftITMom[1] = mLeftITMom[2] = "---";
mRightITMom[0] = mRightITMom[1] = mRightITMom[2] = "---";
}
// Gray-out any irrelevant data
this->GetDlgItem(IDC_LeftITMomX)->EnableWindow(enableIT);
this->GetDlgItem(IDC_LeftITMomY)->EnableWindow(enableIT);
this->GetDlgItem(IDC_LeftITMomZ)->EnableWindow(enableIT);
this->GetDlgItem(IDC_RightITMomX)->EnableWindow(enableIT);
this->GetDlgItem(IDC_RightITMomY)->EnableWindow(enableIT);
this->GetDlgItem(IDC_RightITMomZ)->EnableWindow(enableIT);
mHeader = lDocPtr->ReportHeader();
mFooter = lDocPtr->ReportFooter();
UpdateData(FALSE);
UpdateUnits();
Skeleton &lSkeleton = *lDocPtr->GetSkeleton();
mHandForceTxtLVal.Format("%.1f", lSkeleton.getExtForce(JT_LHAND).length());
mHandForceTxtRVal.Format("%.1f", lSkeleton.getExtForce(JT_RHAND).length());
Vector3 offsetCoordinate = lDocPtr->getOffset();
Vector3 LHand = lSkeleton.getJoint(JT_LHAND);
mLeftHori.Format("%.1f", (LHand[1] - offsetCoordinate[1]));
mLeftLat.Format("%.1f", (LHand[0] - offsetCoordinate[0]));
mLeftVert.Format("%.1f", (LHand[2] - offsetCoordinate[2]));
Vector3 RHand = lSkeleton.getJoint(JT_RHAND);
mRightHori.Format("%.1f", (RHand[1] - offsetCoordinate[1]));
mRightLat.Format("%.1f", (RHand[0] - offsetCoordinate[0]));
mRightVert.Format("%.1f", (RHand[2] - offsetCoordinate[2]));
}
