void Reprojection::updateBounds()
{
const Bounds<double>& oldBounds = getBounds();
double minx = oldBounds.getMinimum(0);
double miny = oldBounds.getMinimum(1);
double minz = oldBounds.getMinimum(2);
double maxx = oldBounds.getMaximum(0);
double maxy = oldBounds.getMaximum(1);
double maxz = oldBounds.getMaximum(2);
try {
transform(minx, miny, minz);
transform(maxx, maxy, maxz);
} catch (pdal::pdal_error&)
{
return;
}
Bounds<double> newBounds(minx, miny, minz, maxx, maxy, maxz);
setBounds(newBounds);
return;
}
void RenderWidget::updateWidgetPosition()
{
if (!m_widget)
return;
int x;
int y;
absolutePosition(x, y);
x += borderLeft() + paddingLeft();
y += borderTop() + paddingTop();
int width = m_width - borderLeft() - borderRight() - paddingLeft() - paddingRight();
int height = m_height - borderTop() - borderBottom() - paddingTop() - paddingBottom();
IntRect newBounds(x, y, width, height);
IntRect oldBounds(m_widget->frameGeometry());
if (newBounds != oldBounds) {
// The widget changed positions. Update the frame geometry.
if (checkForRepaintDuringLayout()) {
RenderView* v = view();
if (!v->printing()) {
v->repaintViewRectangle(oldBounds);
v->repaintViewRectangle(newBounds);
}
}
RenderArena* arena = ref();
element()->ref();
m_widget->setFrameGeometry(newBounds);
element()->deref();
deref(arena);
}
}
void InPlaceReprojection::updateBounds(PointBuffer& buffer)
{
const Bounds<double>& oldBounds = buffer.getSpatialBounds();
double minx = oldBounds.getMinimum(0);
double miny = oldBounds.getMinimum(1);
double minz = oldBounds.getMinimum(2);
double maxx = oldBounds.getMaximum(0);
double maxy = oldBounds.getMaximum(1);
double maxz = oldBounds.getMaximum(2);
try
{
m_reprojectionFilter.transform(minx, miny, minz);
m_reprojectionFilter.transform(maxx, maxy, maxz);
}
catch (pdal::pdal_error&)
{
return;
}
Bounds<double> newBounds(minx, miny, minz, maxx, maxy, maxz);
buffer.setSpatialBounds(newBounds);
return;
}
void Screen::flushScaleImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp,
int16 *width_, int16 *height_, int scaleVal) {
Common::Point imgPos(pt.x + frame->sDrawXOffset(scaleVal), pt.y + frame->sDrawYOffset(scaleVal));
Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->sDrawXSize(scaleVal),
imgPos.y + frame->sDrawYSize(scaleVal));
Common::Rect oldBounds(*xp, *yp, *xp + *width_, *yp + *height_);
if (!_flushScreen) {
// See if the areas of the old and new overlap, and if so combine the areas
if (newBounds.intersects(oldBounds)) {
Common::Rect mergedBounds = newBounds;
mergedBounds.extend(oldBounds);
mergedBounds.right += 1;
mergedBounds.bottom += 1;
slamRect(mergedBounds);
} else {
// The two areas are independent, so copy them both
slamRect(newBounds);
slamRect(oldBounds);
}
}
*xp = newBounds.left;
*yp = newBounds.top;
*width_ = newBounds.width();
*height_ = newBounds.height();
}
void Screen::flushImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp,
int16 *width, int16 *height) {
Common::Point imgPos = pt + frame->_offset;
Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->_frame.w, imgPos.y + frame->_frame.h);
Common::Rect oldBounds(*xp, *yp, *xp + *width, *yp + *height);
if (!_flushScreen) {
// See if the areas of the old and new overlap, and if so combine the areas
if (newBounds.intersects(oldBounds)) {
Common::Rect mergedBounds = newBounds;
mergedBounds.extend(oldBounds);
mergedBounds.right += 1;
mergedBounds.bottom += 1;
slamRect(mergedBounds);
} else {
// The two areas are independent, so copy them both
slamRect(newBounds);
slamRect(oldBounds);
}
}
*xp = newBounds.left;
*yp = newBounds.top;
*width = newBounds.width();
*height = newBounds.height();
}
void RenderWidget::updateWidgetPosition()
{
if (!m_widget)
return;
// FIXME: This doesn't work correctly with transforms.
FloatPoint absPos = localToAbsolute();
absPos.move(borderLeft() + paddingLeft(), borderTop() + paddingTop());
int w = width() - borderLeft() - borderRight() - paddingLeft() - paddingRight();
int h = height() - borderTop() - borderBottom() - paddingTop() - paddingBottom();
IntRect newBounds(absPos.x(), absPos.y(), w, h);
IntRect oldBounds(m_widget->frameRect());
if (newBounds != oldBounds) {
// The widget changed positions. Update the frame geometry.
if (checkForRepaintDuringLayout()) {
RenderView* v = view();
if (!v->printing()) {
// FIXME: do container-relative repaint
v->repaintRectangleInViewAndCompositedLayers(oldBounds);
v->repaintRectangleInViewAndCompositedLayers(newBounds);
}
}
RenderArena* arena = ref();
element()->ref();
m_widget->setFrameRect(newBounds);
element()->deref();
deref(arena);
}
}
void RenderWidget::updateWidgetPosition()
{
if (!m_widget)
return;
// FIXME: This doesn't work correctly with transforms.
FloatPoint absPos = localToAbsolute();
absPos.move(borderLeft() + paddingLeft(), borderTop() + paddingTop());
int w = width() - borderLeft() - borderRight() - paddingLeft() - paddingRight();
int h = height() - borderTop() - borderBottom() - paddingTop() - paddingBottom();
IntRect newBounds(absPos.x(), absPos.y(), w, h);
IntRect oldBounds(m_widget->frameRect());
bool boundsChanged = newBounds != oldBounds;
if (boundsChanged) {
RenderArena* arena = ref();
node()->ref();
m_widget->setFrameRect(newBounds);
node()->deref();
deref(arena);
}
// if the frame bounds got changed, or if view needs layout (possibly indicating
// content size is wrong) we have to do a layout to set the right widget size
if (m_widget->isFrameView()) {
FrameView* frameView = static_cast<FrameView*>(m_widget.get());
if (boundsChanged || frameView->needsLayout())
frameView->layout();
}
}
ZDCRgn ZSubPane::HandleFramePostChange(ZPoint inWindowLocation)
{
ZRect newBounds(ZRect::sZero);
if (this->GetVisible())
newBounds = ZRect(this->GetSize())+inWindowLocation;
return this->DoFramePostChange(fPriorBounds, newBounds);
}
void newQpGenDense( double ** c, int nx, double ** Q,
double ** xlow, char ** ixlow,
double ** xupp, char ** ixupp,
double ** A, int my, double ** b,
double ** C, int mz,
double ** clow, char ** iclow,
double ** cupp, char ** icupp,
int * ierr )
{
*c = NULL; *Q = NULL;
*xlow = NULL; *ixlow = NULL; *xupp = NULL; *ixupp = NULL;
*A = NULL; *b = NULL;
*C = NULL;
*clow = NULL; *iclow = NULL; *cupp = NULL; *icupp = NULL;
*c = (double *) malloc( nx * sizeof( double ) );
if( *c != NULL ) {
*ierr = 0;
} else {
*ierr = 1;
}
if( 0 == *ierr ) newBounds( xlow, nx, ixlow, xupp, ixupp, ierr );
if( 0 == *ierr ) newBounds( clow, mz, iclow, cupp, icupp, ierr );
if( 0 == *ierr ) {
*Q = (double *) malloc( nx * nx * sizeof( double ) );
if( *Q == NULL ) *ierr = 1;
}
if( 0 == *ierr && my > 0 ) {
*A = (double *) malloc( nx * my * sizeof(double) );
*b = (double *) malloc( my * sizeof( double ) );
if( *A == NULL || *b == NULL ) *ierr = 1;
}
if( 0 == *ierr && mz > 0 ) {
*C = (double *) malloc( nx * mz * sizeof( double ) );
if( *C == NULL ) *ierr = 1;
}
if( *ierr != 0 ) {
freeQpGenDense( c, Q, xlow, ixlow, xupp, ixupp,
A, b,
C, clow, iclow, cupp, icupp );
}
}
void SearchAgent::reset(const SteerLib::AgentInitialConditions & initialConditions, SteerLib::EngineInterface * engineInfo)
{
// compute the "old" bounding box of the agent before it is reset. its OK that it will be invalid if the agent was previously disabled
// because the value is not used in that case.
std::cout<<"Reset is called";
Util::AxisAlignedBox oldBounds(__position.x-_radius, __position.x+_radius, 0.0f, 0.0f, __position.z-_radius, __position.z+_radius);
// initialize the agent based on the initial conditions
__position = initialConditions.position;
_forward = initialConditions.direction;
_radius = initialConditions.radius;
_velocity = initialConditions.speed * Util::normalize(initialConditions.direction);
// compute the "new" bounding box of the agent
Util::AxisAlignedBox newBounds(__position.x-_radius, __position.x+_radius, 0.0f, 0.0f, __position.z-_radius, __position.z+_radius);
if (!_enabled) {
// if the agent was not enabled, then it does not already exist in the database, so add it.
gSpatialDatabase->addObject( this, newBounds);
}
else {
// if the agent was enabled, then the agent already existed in the database, so update it instead of adding it.
gSpatialDatabase->updateObject( this, oldBounds, newBounds);
}
_enabled = true;
if (initialConditions.goals.size() == 0) {
throw Util::GenericException("No goals were specified!\n");
}
// iterate over the sequence of goals specified by the initial conditions.
for (unsigned int i=0; i<initialConditions.goals.size(); i++) {
if (initialConditions.goals[i].goalType == SteerLib::GOAL_TYPE_SEEK_STATIC_TARGET) {
_goalQueue.push(initialConditions.goals[i]);
if (initialConditions.goals[i].targetIsRandom) {
// if the goal is random, we must randomly generate the goal.
_goalQueue.back().targetLocation = gSpatialDatabase->randomPositionWithoutCollisions(1.0f, true);
}
}
else {
throw Util::GenericException("Unsupported goal type; SearchAgent only supports GOAL_TYPE_SEEK_STATIC_TARGET.");
}
}
assert(_forward.length()!=0.0f);
assert(_goalQueue.size() != 0);
assert(_radius != 0.0f);
}
void SurfaceProperties::applyBounds(PropertyImpl<canvas::Rect> *prop) {
bool needRefresh=false;
// Get new bounds
canvas::Rect newBounds(_bounds);
calculateBounds(newBounds);
LDEBUG("SurfaceProperties", "apply bounds: (%d,%d,%d,%d)", newBounds.x, newBounds.y, newBounds.w, newBounds.h);
{ // Compare size
const canvas::Size newSize( newBounds );
const canvas::Size &curSize=surface()->getSize();
if (newSize != curSize) {
// Create a new surface from current
surface()->resize( newSize );
needRefresh = true;
// Notify to dependents
if (!_onSizeChanged.empty()) {
_onSizeChanged( newSize );
}
}
}
{ // Compare location
const canvas::Point newPoint( newBounds );
const canvas::Point &curPoint=surface()->getLocation();
if (newPoint != curPoint) {
surface()->setLocation( newPoint );
// Notify to dependents
if (!_onPositionChanged.empty()) {
_onPositionChanged( newPoint );
}
}
}
// Refresh if necesary
prop->setNeedResfresh(needRefresh);
}
void CurveAgent::_doEulerStep(const Util::Vector & steeringDecisionForce, float dt)
{
// compute acceleration, _velocity, and newPosition by a simple Euler step
const Util::Vector clippedForce = Util::clamp(steeringDecisionForce, MAX_FORCE_MAGNITUDE);
Util::Vector acceleration = (clippedForce / AGENT_MASS);
_velocity = _velocity + (dt*acceleration);
_velocity = clamp(_velocity, MAX_SPEED); // clamp _velocity to the max speed
const Util::Point newPosition = __position + (dt*_velocity);
// For this simple agent, we just make the orientation point along the agent's current velocity.
if (_velocity.lengthSquared() != 0.0f) {
_forward = normalize(_velocity);
}
// update the database with the new agent's setup
Util::AxisAlignedBox oldBounds(__position.x - _radius, __position.x + _radius, 0.0f, 0.0f, __position.z - _radius, __position.z + _radius);
Util::AxisAlignedBox newBounds(newPosition.x - _radius, newPosition.x + _radius, 0.0f, 0.0f, newPosition.z - _radius, newPosition.z + _radius);
gSpatialDatabase->updateObject( this, oldBounds, newBounds);
__position = newPosition;
}
void SearchAgent::updateAI(float timeStamp, float dt, unsigned int frameNumber)
{
Util::AutomaticFunctionProfiler profileThisFunction( &SearchAIGlobals::gPhaseProfilers->aiProfiler );
double steps = (DURATION/(double)__path.size());
if(timeStamp*dt > last_waypoint*steps)
{
if(!_goalQueue.empty())
{
Util::AxisAlignedBox oldBounds(__position.x - _radius, __position.x + _radius, 0.0f, 0.0f, __position.z - _radius, __position.z + _radius);
__position = _goalQueue.front().targetLocation;
std::cout << "Waypoint: " << __position;
_goalQueue.pop();
last_waypoint++;
Util::AxisAlignedBox newBounds(__position.x - _radius, __position.x + _radius, 0.0f, 0.0f, __position.z - _radius, __position.z + _radius);
gSpatialDatabase->updateObject(this, oldBounds, newBounds);
}
}
}
void CurveAgent::updateAI(float timeStamp, float dt, unsigned int frameNumber)
{
//For this function, we assume that all goals are of type GOAL_TYPE_SEEK_STATIC_TARGET.
//The error check for this was performed in reset().
Util::AutomaticFunctionProfiler profileThisFunction( &CurveAIGlobals::gPhaseProfilers->aiProfiler );
Util::Point newPosition;
//Move one step on hermiteCurve
if (!curve.calculatePoint(newPosition, timeStamp+dt))
{
disable();
return;
}
//Update the database with the new agent's setup
Util::AxisAlignedBox oldBounds(__position.x - _radius, __position.x + _radius, 0.0f, 0.0f, __position.z - _radius, __position.z + _radius);
Util::AxisAlignedBox newBounds(newPosition.x - _radius, newPosition.x + _radius, 0.0f, 0.0f, newPosition.z - _radius, newPosition.z + _radius);
gSpatialDatabase->updateObject(this, oldBounds, newBounds);
//Update current position
__position = newPosition;
}
void quadtree::_divide()
{
sf::FloatRect newBounds(_bound.left, _bound.top,
_bound.width / 2.f, _bound.height / 2.f);
_nWest = std::make_shared<quadtree>(quadtree(newBounds, this, _level + 1));
newBounds = { _bound.left + (_bound.width / 2.f), _bound.top,
_bound.width / 2.f, _bound.height / 2.f};
_nEast = std::make_shared<quadtree>(quadtree(newBounds, this, _level + 1));
newBounds = { _bound.left , _bound.top + (_bound.height / 2.f),
_bound.width / 2.f, _bound.height / 2.f };
_sWest = std::make_shared<quadtree>(quadtree(newBounds, this, _level + 1));
newBounds = { _bound.left + (_bound.width / 2.f), _bound.top + (_bound.height / 2.f),
_bound.width / 2.f, _bound.height / 2.f };
_sEast = std::make_shared<quadtree>(quadtree(newBounds, this, _level + 1));
for (auto &obj : _objectsInNode)
{
add(obj);
}
_objectsInNode.clear();
}
void TrainModelNN (_String* model, _String* matrix)
{
_String errMsg;
long modelIdx = modelNames.Find(model);
_Parameter verbI;
checkParameter (VerbosityLevelString, verbI, 0.0);
char buffer [128];
if (modelIdx < 0) {
errMsg = *model & " did not refer to an existring model";
} else {
_Variable* boundsMatrix = FetchVar (LocateVarByName (*matrix));
if (boundsMatrix && (boundsMatrix->ObjectClass() == MATRIX)) {
_Matrix * bmatrix = (_Matrix*) boundsMatrix->GetValue ();
if (bmatrix->IsAStringMatrix() && (bmatrix->GetVDim () == 3)) {
_Variable* modelMatrix = LocateVar (modelMatrixIndices.lData[modelIdx]);
_SimpleList modelVariableList;
{
_AVLList mvla (&modelVariableList);
modelMatrix->ScanForVariables (mvla, true);
mvla.ReorderList();
}
if (bmatrix->GetHDim () == modelVariableList.lLength) {
// now map model variables to bounds matrix
_SimpleList variableMap;
_String *myName;
for (long k = 0; k < modelVariableList.lLength; k++) {
myName = ((_FString*)bmatrix->GetFormula(k,0)->Compute())->theString;
long vID = LocateVarByName (*myName);
if (vID < 0) {
break;
}
vID = variableNames.GetXtra (vID);
vID = modelVariableList.Find(vID);
if (vID < 0) {
break;
}
variableMap << vID;
}
if (variableMap.lLength == modelVariableList.lLength) {
_Matrix vBounds (variableMap.lLength,2, false, true);
long k2 = 0;
for (; k2 < variableMap.lLength; k2++) {
_Parameter lb = ((_FString*)bmatrix->GetFormula(k2,1)->Compute())->theString->toNum(),
ub = ((_FString*)bmatrix->GetFormula(k2,2)->Compute())->theString->toNum();
if ( ub>lb || k2) {
vBounds.Store (k2,0,lb);
vBounds.Store (k2,1,ub);
if (ub<=lb && vBounds (k2-1,0) <= vBounds (k2-1,1) && (!CheckEqual(vBounds (k2-1,0),0.0) || !CheckEqual(vBounds (k2-1,1),1.0))) {
break;
}
}
}
if (k2 == modelVariableList.lLength) {
// set up the sampling now
_String fName = ProcessLiteralArgument (&ModelNNFile,nil);
FILE* nnFile = doFileOpen (fName.getStr(), "w");
if (nnFile) {
_Matrix* modelMatrix = (_Matrix*) LocateVar(modelMatrixIndices.lData[modelIdx])->GetValue();
_Parameter mainSteps,
checkSteps,
errorTerm,
loopMax,
hiddenNodes,
absError,
nn1,
nn2;
long fullDimension = modelMatrix->GetHDim() * modelMatrix->GetVDim();
checkParameter (ModelNNTrainingSteps, mainSteps, 10000.0);
checkParameter (ModelNNVerificationSample, checkSteps, 500.0);
checkParameter (ModelNNPrecision, errorTerm, 0.01);
checkParameter (ModelNNTrainingSteps, loopMax, 10);
checkParameter (ModelNNHiddenNodes, hiddenNodes, 5);
checkParameter (ModelNNLearningRate, nn1, .3);
checkParameter (ModelNNPersistenceRate, nn2, .1);
Net** matrixNet = new Net* [fullDimension] ;
for (long i = 0; i < fullDimension; i++) {
checkPointer (matrixNet [i] = new Net (variableMap.lLength,(long)hiddenNodes,1,errorTerm,nn1,nn2,100,200,true));
//matrixNet[i]->verbose = true;
}
checkPointer (matrixNet);
_List tIn,
tOut;
FILE* varSamples = doFileOpen ("variableSamples.out", "w");
fprintf (varSamples, "%s" ,LocateVar(modelVariableList.lData[0])->GetName()->getStr());
for (long vc = 1; vc < modelVariableList.lLength; vc++) {
fprintf (varSamples, ",%s" ,LocateVar(modelVariableList.lData[variableMap.lData[vc]])->GetName()->getStr());
}
fprintf (varSamples, "\n");
for (long itCount = 0; itCount < loopMax; itCount ++) {
if (verbI > 5) {
snprintf (buffer, sizeof(buffer), "\nNeural Network Pass %ld. Building a training set...\n", itCount);
BufferToConsole (buffer);
}
while (tIn.countitems() < mainSteps) {
NNMatrixSampler (0, vBounds, modelVariableList, variableMap, modelMatrix, tIn, tOut);
}
_Matrix inData (mainSteps, variableMap.lLength, false, true);
_Parameter *md = inData.theData;
for (long matrixC = 0; matrixC < mainSteps; matrixC++) {
_Parameter * ed = ((_Matrix*)tIn (matrixC))->theData;
fprintf (varSamples, "\n%g",*ed);
*md = *ed;
ed++;
md++;
for (long entryC = 1; entryC < variableMap.lLength; entryC++, ed++, md++) {
*md = *ed;
fprintf (varSamples, ",%g", *md);
}
}
tIn.Clear();
if (verbI > 5) {
BufferToConsole ( "Done Building Training Set. Training...\n");
}
long lastDone = 0;
for (long cellCount = 0; cellCount < fullDimension; cellCount++) {
Net* thisCell = matrixNet[cellCount];
_Matrix outVector (mainSteps, 1, false, true);
for (long oc = 0; oc < mainSteps; oc++) {
outVector.theData[oc] = ((_Matrix*)tOut(oc))->theData[cellCount];
}
thisCell->studyAll (inData.theData, outVector.theData, mainSteps);
long nowDone = (cellCount+1)*100./fullDimension;
if (nowDone > lastDone) {
snprintf (buffer, sizeof(buffer),"%ld%% done\n", lastDone = nowDone);
BufferToConsole (buffer);
}
}
tOut.Clear();
if (verbI > 5) {
BufferToConsole ( "Done Training. Resampling...\n");
}
_PMathObj tObj = _Constant(0).Time();
_Parameter time1 = tObj->Value(),
time2;
while (tIn.countitems() < checkSteps) {
NNMatrixSampler (0, vBounds, modelVariableList, variableMap, modelMatrix, tIn, tOut);
}
absError = 0.0;
DeleteObject (tObj);
tObj = _Constant(0).Time();
time2 = tObj->Value();
if (verbI > 5) {
snprintf (buffer, sizeof(buffer),"Done Resampling in %g seconds. Computing Error...\n", time2-time1);
BufferToConsole (buffer);
}
_Parameter maxValT,
maxValE;
for (long verCount = 0; verCount < checkSteps; verCount++) {
_Parameter* inData = ((_Matrix*)tIn(verCount))->theData,
* outData = ((_Matrix*)tOut(verCount))->theData;
for (long cellCount = 0; cellCount < fullDimension; cellCount++) {
Net *thisCell = matrixNet[cellCount];
_Parameter estVal = thisCell->eval(inData)[0],
trueVal = outData[cellCount],
localError;
localError = estVal-trueVal;
if (localError < 0) {
localError = -localError;
}
if (absError < localError) {
maxValT = trueVal;
maxValE = estVal;
absError = localError;
}
}
}
DeleteObject (tObj);
tObj = _Constant(0).Time();
time1 = tObj->Value();
DeleteObject (tObj);
if (verbI > 5) {
snprintf (buffer, sizeof(buffer), "Done Error Checking in %g seconds. Got max abs error %g on the pair %g %g\n", time1-time2, absError, maxValT, maxValE);
BufferToConsole (buffer);
}
if (absError <= errorTerm) {
break;
}
}
if (absError > errorTerm) {
ReportWarning (_String("Couldn't achive desired precision in TrainModelNN. Achieved error of ") & absError);
}
fclose (varSamples);
fprintf (nnFile,"{{\n\"%s\"", LocateVar(modelVariableList.lData[0])->GetName()->getStr());
_Matrix newBounds (modelVariableList.lLength, 2, false, true);
if (vBounds(0,0)>vBounds(0,1)) {
newBounds.Store (variableMap.lData[0],0,0.);
newBounds.Store (variableMap.lData[0],1,1.);
} else {
newBounds.Store (variableMap.lData[0],0,vBounds(0,0));
newBounds.Store (variableMap.lData[0],1,vBounds(0,1));
}
for (long varCounter = 1; varCounter < modelVariableList.lLength; varCounter ++) {
fprintf (nnFile,",\n\"%s\"", LocateVar(modelVariableList.lData[varCounter])->GetName()->getStr());
if (vBounds(varCounter,0)>vBounds(varCounter,1)) {
newBounds.Store (variableMap.lData[varCounter],0,0.);
newBounds.Store (variableMap.lData[varCounter],1,1.);
} else {
newBounds.Store (variableMap.lData[varCounter],0,vBounds(varCounter,0));
newBounds.Store (variableMap.lData[varCounter],1,vBounds(varCounter,1));
}
}
fprintf (nnFile,"\n}}\n");
newBounds.toFileStr (nnFile);
for (long i2 = 0; i2 < fullDimension; i2++) {
matrixNet[i2]->save(nnFile);
delete matrixNet [i2];
}
fclose (nnFile);
delete matrixNet;
} else {
errMsg = _String ("Failed to open ") & fName & " for writing";
}
} else {
errMsg = _String ("Invalid variable bounds in row ") & (k2+1) & " of the bounds matrix";
}
} else {
errMsg = *myName & " was not one of the model parameters";
}
} else {
errMsg = *matrix & " must be a have the same number of rows as the number of model parameters";
}
} else {
errMsg = *matrix & " must be a string matrix with 3 columns";
}
} else {
errMsg = *matrix & " was not the identifier of a valid matrix variable";
}
}
if (errMsg.sLength) {
errMsg = errMsg & _String(" in call to TrainModelNN.");
WarnError (errMsg);
}
}
void CurveAgent::reset(const SteerLib::AgentInitialConditions & initialConditions, SteerLib::EngineInterface * engineInfo)
{
// compute the "old" bounding box of the agent before it is reset. its OK that it will be invalid if the agent was previously disabled
// because the value is not used in that case.
Util::AxisAlignedBox oldBounds(__position.x-_radius, __position.x+_radius, 0.0f, 0.0f, __position.z-_radius, __position.z+_radius);
// initialize the agent based on the initial conditions
__startPosition = initialConditions.position;
__position = initialConditions.position;
_forward = initialConditions.direction;
_radius = initialConditions.radius;
_velocity = initialConditions.speed * Util::normalize(initialConditions.direction);
// Find random agent color
if (initialConditions.colorSet)
agentColor = initialConditions.color;
else
{
std::random_device seed;
std::default_random_engine generator(seed());
std::uniform_real_distribution<float> distribution(0.0f, 0.8f);
agentColor = Util::Color(distribution(generator), distribution(generator), distribution(generator));
}
// compute the "new" bounding box of the agent
Util::AxisAlignedBox newBounds(__position.x-_radius, __position.x+_radius, 0.0f, 0.0f, __position.z-_radius, __position.z+_radius);
if (!_enabled) {
// if the agent was not enabled, then it does not already exist in the database, so add it.
gSpatialDatabase->addObject( this, newBounds);
}
else {
// if the agent was enabled, then the agent already existed in the database, so update it instead of adding it.
gSpatialDatabase->updateObject( this, oldBounds, newBounds);
}
_enabled = true;
if (initialConditions.goals.size() == 0) {
throw Util::GenericException("No goals were specified!\n");
}
// iterate over the sequence of goals specified by the initial conditions.
for (unsigned int i=0; i<initialConditions.goals.size(); i++) {
if (initialConditions.goals[i].goalType == SteerLib::GOAL_TYPE_SEEK_STATIC_TARGET) {
_goalQueue.push_back(initialConditions.goals[i]);
if (initialConditions.goals[i].targetIsRandom) {
// if the goal is random, we must randomly generate the goal.
_goalQueue.back().targetLocation = gSpatialDatabase->randomPositionWithoutCollisions(1.0f, true);
}
}
else {
throw Util::GenericException("Unsupported goal type; CurveAgent only supports GOAL_TYPE_SEEK_STATIC_TARGET.");
}
}
// Add control points to curve
std::vector<Util::CurvePoint> controlPoints;
Util::Vector startTangent(0.f, 0.f, 0.f);
controlPoints.push_back(Util::CurvePoint(__position, startTangent, 0.f));
for (int i = 0; i < _goalQueue.size(); i++)
{
controlPoints.push_back(Util::CurvePoint(_goalQueue[i].targetLocation, _goalQueue[i].targetTangent, _goalQueue[i].targetTime));
}
curve.addControlPoints(controlPoints);
assert(_forward.length()!=0.0f);
assert(_goalQueue.size() != 0);
assert(_radius != 0.0f);
}
void
DialogPane::SetMode(int32 mode, bool initialSetup)
{
ASSERT(mode < 3 && mode >= 0);
if (!initialSetup && mode == fMode)
return;
int32 oldMode = fMode;
fMode = mode;
bool followBottom = (ResizingMode() & B_FOLLOW_BOTTOM) != 0;
// if we are follow bottom, we will move ourselves, need to place us back
float bottomOffset = 0;
if (followBottom && Window() != NULL)
bottomOffset = Window()->Bounds().bottom - Frame().bottom;
BRect newBounds(BoundsForMode(fMode));
if (!initialSetup)
ResizeParentWindow(fMode, oldMode);
ResizeTo(newBounds.Width(), newBounds.Height());
float delta = 0;
if (followBottom && Window() != NULL)
delta = (Window()->Bounds().bottom - Frame().bottom) - bottomOffset;
if (delta != 0) {
MoveBy(0, delta);
if (fLatch && (fLatch->ResizingMode() & B_FOLLOW_BOTTOM))
fLatch->MoveBy(0, delta);
}
switch (fMode) {
case 0:
{
if (oldMode > 1)
fMode3Items.RemoveAll(this);
if (oldMode > 0)
fMode2Items.RemoveAll(this);
BView *separator = FindView("separatorLine");
if (separator) {
BRect frame(separator->Frame());
frame.InsetBy(-1, -1);
RemoveChild(separator);
Invalidate();
}
AddChild(new SeparatorLine(BPoint(newBounds.left, newBounds.top
+ newBounds.Height() / 2), newBounds.Width(), false,
"separatorLine"));
break;
}
case 1:
{
if (oldMode > 1)
fMode3Items.RemoveAll(this);
else
fMode2Items.AddAll(this);
BView *separator = FindView("separatorLine");
if (separator) {
BRect frame(separator->Frame());
frame.InsetBy(-1, -1);
RemoveChild(separator);
Invalidate();
}
break;
}
case 2:
{
fMode3Items.AddAll(this);
if (oldMode < 1)
fMode2Items.AddAll(this);
BView *separator = FindView("separatorLine");
if (separator) {
BRect frame(separator->Frame());
frame.InsetBy(-1, -1);
RemoveChild(separator);
Invalidate();
}
break;
}
}
}
void OperationsController::setupPipeline(cv::Mat initialFrame)
{
cv::Size bounds = initialFrame.size();
emit newBounds(0, bounds.width, 0, bounds.height);
}
