bool CTrackedNodeMgr::LinkNodes( HTRACKEDNODE ChildID, HTRACKEDNODE ParentID )
{
//make sure the nodes are valid
if(!CheckValidity(ChildID) || !CheckValidity(ParentID))
return false;
ParentID->m_pChild = ChildID;
return true;
}
int CWavFile::IsCanCombine(CString strPathL, CString strPathR)
{
BOOL b = FALSE;
DWORD m_dwDataSizeL = 0;
DWORD m_dwDataSizeR = 0;
memset(&m_formatL, 0, sizeof(WAVEFORMATEX));
memset(&m_formatR, 0, sizeof(WAVEFORMATEX));
ZeroMemory(&m_mmckinfoParent, sizeof(MMCKINFO));
ZeroMemory(&m_mmckinfoSubChunk, sizeof(MMCKINFO));
// Check Validity of the first(left channel) file
m_dwDataSizeL = CheckValidity(m_hWaveFileL, strPathL, m_formatL);
if(m_dwDataSizeL == -1)
{
MyMessageBox(_T("Invalid wave file: ") + strPathL, eERR_ERROR);
return -1;
}
// Check Validity of the second(right channel) file
m_dwDataSizeR = CheckValidity(m_hWaveFileR, strPathR, m_formatR);
if(m_dwDataSizeR == -1)
{
MyMessageBox(_T("Invalid wave file: ") + strPathR, eERR_ERROR);
return -1;
}
// All of them must be mono wave file
if(!(m_formatL.nChannels == 1))
{
MyMessageBox(_T("Not a mono wave file: ") + strPathL, eERR_ERROR);
return -1;
}
if(!(m_formatR.nChannels == 1))
{
MyMessageBox(_T("Not a mono wave file: ") + strPathR, eERR_ERROR);
return -1;
}
// They must have the same bps
if(!(m_formatL.wBitsPerSample == m_formatR.wBitsPerSample))
{
MyMessageBox(_T("They must have the same bps"), eERR_ERROR);
return -1;
}
// They must have the same sps
if(m_formatL.nSamplesPerSec != m_formatR.nSamplesPerSec)
{
MyMessageBox(_T("They must have the same sps"), eERR_ERROR);
return -1;
}
return max(m_dwDataSizeL, m_dwDataSizeR);
}
bool CTrackedNodeMgr::LinkNodeOrientation( HTRACKEDNODE ID,
HTRACKEDNODE CopyFrom )
{
//check the params and parent object
if(!CheckValidity(ID) || !CheckValidity(CopyFrom))
return false;
//ok, setup the link pointer
ID->m_pMimicNode = CopyFrom;
//success
return true;
}
GridDefinition::GridDefinition(const float xRange[2], const float yRange[2], float pRadius, float pSpacing)
: xMin(xRange[0]), xMax(xRange[1]), yMin(yRange[0]), yMax(yRange[1]), radius(pRadius), spacing(pSpacing), recipSpacing(1.0/spacing)
{
numX = (xMax - xMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((xMax - xMin) * recipSpacing) + 1 : 0;
numY = (yMax - yMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((yMax - yMin) * recipSpacing) + 1 : 0;
CheckValidity();
}
/********************************************************************
Savcor IT Oy/JLM
Borland TURBO C++ 3.0
Declaration: Parse received message
Call: ret=ParseMessage(ReceiveBuffer)
Input: char *ReceiveBuffer
Returns: char *ret
01.12.2000 Initial coding JLM
*********************************************************************/
void ParseMessage(char *OutMes)
{
int i;
int j=0;
char token[BUFFER_SIZE];
strcpy(OutMes,"");
strcpy(tempbuf,"");
for (i=1;i<(int)strlen(Message);i++)
{
if (IsAlpha(Message[i]) && ( i < ((int)strlen(Message)-1)))
token[j++]=Message[i];
else
{
if (j>0)
{
token[j]=0; // end of string
strcpy(tempbuf,"");
CheckValidity(token);
if ( (!DispWithoutLabels) && (strlen(tempbuf)>0))
{
strcat(OutMes,token);
strcat(OutMes,"=");
}
strcat(OutMes,tempbuf);
//printf ("OutMes=%s\n",OutMes);
}
j=0;
} // else
}
}
bool CTrackedNodeMgr::IsLookingAtTarget( HTRACKEDNODE ID)
{
if(!CheckValidity(ID))
return false;
return ID->m_bLookingAtTarget;
}
bool CSettingString::SetValue(const std::string &value)
{
CSingleLock lock(m_critical);
if (value == m_value)
return true;
if (!CheckValidity(value))
return false;
std::string oldValue = m_value;
m_value = value;
if (!OnSettingChanging(this))
{
m_value = oldValue;
// the setting couldn't be changed because one of the
// callback handlers failed the OnSettingChanging()
// callback so we need to let all the callback handlers
// know that the setting hasn't changed
OnSettingChanging(this);
return false;
}
m_changed = m_value != m_default;
OnSettingChanged(this);
return true;
}
bool CTrackedNodeMgr::SetTarget( HTRACKEDNODE ID, HOBJECT hModel, HMODELNODE hNode, const LTVector& vOffset )
{
if(!CheckValidity(ID))
return false;
//make sure that the model pointed to is not ourself, this can cause infinite
//recursion
assert(hModel != ID->m_hModel);
//make sure that that is actually a valid model
uint32 nType;
if(m_pILTBase->Common()->GetObjectType(hModel, &nType) != LT_OK)
return false;
if(nType != OT_MODEL)
return false;
//make sure we have a valid node
if(hNode == INVALID_MODEL_NODE)
return false;
//setup this target
ID->m_eTrackMode = CTrackedNode::TRACK_NODE;
ID->m_hTrackObject = hModel;
ID->m_hTrackNode = hNode;
ID->m_vTrackOffset = vOffset;
//success
return true;
}
bool CSettingNumber::SetValue(double value)
{
CExclusiveLock lock(m_critical);
if (value == m_value)
return true;
if (!CheckValidity(value))
return false;
double oldValue = m_value;
m_value = value;
if (!OnSettingChanging(this))
{
m_value = oldValue;
// the setting couldn't be changed because one of the
// callback handlers failed the OnSettingChanging()
// callback so we need to let all the callback handlers
// know that the setting hasn't changed
OnSettingChanging(this);
return false;
}
m_changed = m_value != m_default;
OnSettingChanged(this);
return true;
}
bool CTrackedNodeMgr::IsAtDiscomfort( HTRACKEDNODE ID)
{
if(!CheckValidity(ID))
return false;
return ID->m_bInDiscomfort;
}
bool CTrackedNodeMgr::IsTracking( HTRACKEDNODE ID )
{
if(!CheckValidity(ID))
return false;
return ID->m_bEnabled;
}
bool CTrackedNodeMgr::IsAtLimit( HTRACKEDNODE ID )
{
if(!CheckValidity(ID))
return false;
return ID->m_bAtMaxThreshold;
}
//m_month setter w/ error checking
void cDate::SetMonth(uint8_t month)
{
if (month <= 12 && month != 0)
{
m_month = month;
CheckValidity();
}
}
bool CSettingInt::CheckValidity(const std::string &value) const
{
int iValue;
if (!fromString(value, iValue))
return false;
return CheckValidity(iValue);
}
bool CSettingNumber::CheckValidity(const std::string &value) const
{
double dValue;
if (!fromString(value, dValue))
return false;
return CheckValidity(dValue);
}
// m_day setter w/ error checking
void cDate::SetDay(uint8_t day)
{
if (day <= 31 && day != 0)
{
m_day = day;
CheckValidity();
}
}
bool CTrackedNodeMgr::SetOrientOnAnim( HTRACKEDNODE ID, bool bTrackOnAnim )
{
if(!CheckValidity(ID))
return false;
//just set the flag on the node
ID->m_bOrientFromAnim = bTrackOnAnim;
return true;
}
bool CTrackedNodeMgr::SetIgnoreParentAnimation( HTRACKEDNODE ID, bool bIgnoreParentAnimation )
{
if(!CheckValidity(ID))
return false;
//just set the flag on the node
ID->m_bIgnoreParentAnimation = bIgnoreParentAnimation;
return true;
}
nsresult
nsIConstraintValidation::CheckValidity(bool* aValidity)
{
NS_ENSURE_ARG_POINTER(aValidity);
*aValidity = CheckValidity();
return NS_OK;
}
bool CTrackedNodeMgr::SetAutoDisable( HTRACKEDNODE ID, bool bAutoDisable )
{
if(!CheckValidity(ID))
return false;
//just set the flag on the node
ID->m_bAutoDisable = bAutoDisable;
return true;
}
void KTorrentImportPage::initializePage ()
{
connect (wizard (),
SIGNAL (accepted ()),
this,
SLOT (handleAccepted ()));
QString defaultFile = QDir::homePath () + "/.kde/share/config/ktorrentrc";
if (CheckValidity (defaultFile))
Ui_.FileLocation_->setText (defaultFile);
}
bool CTrackedNodeMgr::SetTargetObject( HTRACKEDNODE ID, const LTVector& vPosition )
{
if(!CheckValidity(ID))
return false;
//setup this target
ID->m_eTrackMode = CTrackedNode::TRACK_OBJSPACEPOS;
ID->m_vTrackOffset = vPosition;
return true;
}
Trajectory PlanningProblem::RRT_APF_Solve(const ObstacleSet &ob_set,
Trajectory &prior_plan,
bool stop_when_collid)
{
Trajectory *temp_trajec = new Trajectory();
temp_trajec->appendState(initialState);
for(int step = 1; step <= MAX_APF_STEP_TRY; step++) {
// check reaching the goal state
Station current_station = temp_trajec->getLastStation();
if( (goal.minDistTo(current_station) < agent->radius() * 1) )
{
temp_trajec->appendState(goal.goal_point);
planningResult = true;
break;
}
Vector2D total_force;
if( !pathHasCollision(current_station, goal.goal_point, ob_set) ) {
// temp_trajec->appendState(goal.goal_point);
// planningResult = true;
// break;
total_force += GoalAttractiveForce(current_station);
}
// else
{
Station next_goal = getNextStation(current_station, prior_plan);
total_force += PathDirectedForce(current_station, prior_plan);
vector<Vector2D> ob_forces = ObstacleForces(current_station, ob_set);
Vector2D ob_total_force;
for(uint i=0; i<ob_forces.size(); i++) {
ob_total_force += ob_forces[i];
}
if(!pathHasCollision(current_station, next_goal, ob_set)) {
ob_total_force *= 0.2;
}
total_force += ob_total_force;
}
Station new_station;
new_station = agent->step(current_station,
(total_force.normalized()).to3D(),
0.080 /*sec*/);
temp_trajec->appendState(new_station);
if(stop_when_collid) {
if( !CheckValidity(new_station) ) {
planningResult = false;
break;
}
}
}
return *temp_trajec;
}
bool CTrackedNodeMgr::SetTarget( HTRACKEDNODE ID, HOBJECT hObject, const LTVector& vOffset )
{
if(!CheckValidity(ID))
return false;
//setup this target
ID->m_eTrackMode = CTrackedNode::TRACK_OBJECT;
ID->m_hTrackObject = hObject;
ID->m_vTrackOffset = vOffset;
return true;
}
Station PlanningProblem::SampleStateUniform()
{
Station sampled_station;
for(int i=0; i < MAX_SAMPLING_TRY; ++i)
{
Vector3D rand_pos = actualBound->getUniformSample();
sampled_station.setPosition(rand_pos);
if(CheckValidity(sampled_station))
return sampled_station;
}
return Station();
}
bool CTrackedNodeMgr::TargetAnimation( HTRACKEDNODE ID, const LTVector& vOffset )
{
if(!CheckValidity(ID))
return false;
//setup the target
ID->m_eTrackMode = CTrackedNode::TRACK_ANIMATION;
ID->m_vTrackOffset = vOffset;
//success
return true;
}
// Read the grid parameters from a string returning true if success
bool GridDefinition::ReadParameters(const StringRef& s)
{
bool ok = (sscanf(s.Pointer(), "%f,%f,%f,%f,%f,%f,%lu,%lu", &xMin, &xMax, &yMin, &yMax, &radius, &spacing, &numX, &numY) == 8);
if (ok)
{
CheckValidity();
recipSpacing = 1.0 / spacing;
}
else
{
isValid = false;
}
return ok;
}
/* Function definition */
int * GenerateInitPopulation(unsigned int** dMat)
{
int i, city;
int *initialPopulation = (int *)malloc(sizeof(int) * NUM_CITIES * NUM_CITIES) ;
for(city ; city < NUM_CITIES; city++)
{
GenerateTour(city + 1, &initialPopulation[city * NUM_CITIES], dMat);
CheckValidity(&initialPopulation[city * NUM_CITIES] , "init");
}
return initialPopulation;
}
bool CTrackedNodeMgr::GetOrientationSpace( HTRACKEDNODE ID, LTVector& vRight,
LTVector& vUp,
LTVector& vForward)
{
if(!CheckValidity(ID))
return false;
//read in the vectors
LTMatrix mTargetTransform = ID->m_mInvTargetTransform;
mTargetTransform.Transpose();
mTargetTransform.GetBasisVectors(&vRight, &vUp, &vForward);
return true;
}
bool CTrackedNodeMgr::GetBasisSpace( HTRACKEDNODE ID, LTVector& vRight,
LTVector& vUp,
LTVector& vForward,
LTVector& vPos)
{
if(!CheckValidity(ID))
return false;
vRight = ID->m_vActualRight;
vUp = ID->m_vActualUp;
vForward = ID->m_vActualForward;
vPos = ID->m_vActualPos;
return true;
}
