void TrainingSet::initTS(const vector<vector<double> > &inputs, const vector<vector<double> > &targets)
{
setInputs(inputs);
setTargets(targets);
// originalTS = new TrainingSet(*this);
}
path *spreadExecSearchAlgorithm::GetPath(GraphAbstraction *_aMap, node *from, node *to, reservationProvider *_rp)
{
setTargets(_aMap, from, to, _rp);
path *p;
while ((p = think()) == 0) {}
return p;
}
TrainingSet &TrainingSet::operator=(const TrainingSet &trset)
{
setInputs(trset.getInputs());
setTargets(trset.getTargets());
return *this;
}
void VisualTracker::onSimEventSetVisualTracker(SimEventQueue& q,
rutz::shared_ptr<SimEventSetVisualTracker>& e)
{
#ifdef HAVE_OPENCV
Point2D<int> targetLoc = e->getTargetLoc();
LINFO("Set visual tracker to %ix%i",
targetLoc.i,
targetLoc.j);
setTargets(itsCurrentGreyImg, targetLoc);
#endif
}
void RandomActiveTester::setTestingTargets() {
char read_string[MAX_READ_SIZE];
FILE * file_in = fopen(targetfile.c_str(), "r");
setTargets(file_in, read_string, MAX_READ_SIZE);
char out_string[8192];
rotateInputFile(file_in, read_string, out_string, 8192);
log->addAddressToSchedule(target1);
log->addAddressToSchedule(target2);
fclose(file_in);
FILE * file_out = fopen(targetfile.c_str(), "w");
rewriteTargetFile(file_out, out_string);
fclose(file_out);
}
void SelectTargetDialog::setTargetSet(const QString& name)
{
m_targets = NULL;
m_allTargets.clear();
m_targetsList->clear();
m_command->setText("");
m_targetName->clear();
for (int i=0; i<m_targetSets.size(); i++) {
if (m_targetSets.at(i).name == name) {
m_currentTargetSet->setCurrentIndex(i);
setTargets(m_targetSets.at(i).targets);
return;
}
}
}
void Toolbar::render(Editor* editor)
{
//Checks if the selected units are the same
if(mChange)
{
editor->setPlayer(mCurrPlayer);
editor->setUnit(mCurrUnit);
setTargets(editor->mLevel);
mChange=false;
}
if(mDelete)
{
editor->setUnit(mCurrUnit);
editor->setPlayer(mCurrPlayer);
editor->deleteSelected();
mDelete=false;
unIniPlayer();
unIniUnit();
}
//Change UIItems
if(mNewPos)
{
if(editor->collide(mCurrUnit))
{
mCurrUnit.getObject()->setPosition(mCurrUnit.getOriginal());
}
else
{
mCurrUnit.setOriginal(mCurrUnit.getObject()->getPosition());
}
mNewPos=false;
setTargets(editor->mLevel);
}
if(!mSelected)
{
setUIActives();
}
//Renders stuff
RenderWindow& window=editor->getWindow();
window.setView(View(FloatRect(Vector2f(0,0),Vector2f(window.getSize()))));
Vector2f Size(mViewSize.x/window.getSize().x,mViewSize.y/window.getSize().y),
Position(mPosition.x/window.getSize().x,mPosition.y/window.getSize().y);
sf::RectangleShape Bar(mSize),Frame(mSize),Indicator;
Bar.setPosition(mPosition);
Frame.setPosition(mPosition);
Frame.setOutlineThickness(2);
Frame.setOutlineColor(Color(0,0,0,255));
Frame.setFillColor(sf::Color::Transparent);
Bar.setFillColor(mBackground);
window.draw(Bar);
//Renders the minimap
View MiniView=window.getDefaultView();
MiniView.setViewport(FloatRect(Position,Size));
float scale=0;
if(editor->mLevel.getSize().x!=0&&editor->mLevel.getSize().y!=0)
{
scale=window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).x/editor->mLevel.getSize().x;
if(scale>window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).y/editor->mLevel.getSize().y)
{
scale=window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).y/editor->mLevel.getSize().y;
}
}
else
{
scale=window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).x/1280;
if(scale>window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).y/800)
{
scale=window.convertCoords(Vector2i(mPosition+mViewSize),MiniView).y/800;
}
}
if(scale>1)
{
MiniView.zoom(scale);
}
editor->renderLevel(MiniView);
//Renders the rect showing your view on the minimap
Position=window.convertCoords(Vector2i(0,editor->mLevelTool.getSize().y),editor->mCurrView)+Vector2f(10,10);
Size=window.convertCoords(Vector2i(editor->mCurrView.getViewport().width*window.getSize().x,
editor->mCurrView.getViewport().height*window.getSize().y+editor->mLevelTool.getSize().y),editor->mCurrView)-Position-Vector2f(10,10);
Indicator.setSize(Size);
Indicator.setPosition(Position);
Indicator.setFillColor(sf::Color::Transparent);
Indicator.setOutlineColor(sf::Color(255,0,0,255));
Indicator.setOutlineThickness(10);
window.setView(MiniView);
window.draw(Indicator);
//Renders the Frame
window.setView(View(FloatRect(Vector2f(0,0),Vector2f(window.getSize()))));
window.draw(Frame);
//Draws the UIItems
int i=0;
for(UISet::iterator it=mUIItems.accessActive().begin();it!=mUIItems.accessActive().end();it++)
{
int Height=mViewSize.y+5;
for(UISet::iterator et=mUIItems.accessActive().begin();et!=it;et++)
{
Height+=(*et)->getHitBox(Position).height;
}
i++;
(*it)->draw(window,Vector2f(mPosition.x+5,mPosition.y+Height));
}
}
void MultilayerPerceptronPattern::initMLPP(double *targets, size_t s)
{
setTargets(targets, s);
}
void hack_draw (xstuff_t * XStuff, double currentTime, float frameTime)
{
int i;
static int ionsReleased = 0;
static float releaseTime = 0.0f;
Display *dpy = XStuff->display;
#ifdef BENCHMARK
static int a = 1;
#endif
Window window = XStuff->window;
elapsedTime = frameTime;
#ifdef BENCHMARK
if (a++ == 1000)
exit(0);
elapsedTime = 0.1f;
#endif
// Camera movements
// first do translation (distance from center)
static float oldCameraDistance;
static float cameraDistance;
static float targetCameraDistance = -1000.0f;
static float preCameraInterp = PI;
float cameraInterp;
preCameraInterp += float (dCameraspeed) * elapsedTime * 0.01f;
cameraInterp = 0.5f - (0.5f * cos (preCameraInterp));
cameraDistance = (1.0f - cameraInterp) * oldCameraDistance + cameraInterp * targetCameraDistance;
if (preCameraInterp >= PI) {
oldCameraDistance = targetCameraDistance;
targetCameraDistance = -rsRandf (1300.0f) - 200.0f;
preCameraInterp = 0.0f;
}
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (0.0, 0.0, cameraDistance);
// then do rotation
static rsVec radialVel = rsVec (0.0f, 0.0f, 0.0f);
static rsVec targetRadialVel = radialVel;
static rsQuat rotQuat = rsQuat (0.0f, 0.0f, 0.0f, 1.0f);
rsVec radialVelDiff = targetRadialVel - radialVel;
float changeRemaining = radialVelDiff.normalize ();
float change = float (dCameraspeed) * 0.0002f * elapsedTime;
if (changeRemaining > change) {
radialVelDiff *= change;
radialVel += radialVelDiff;
} else {
radialVel = targetRadialVel;
if (rsRandi (2)) {
targetRadialVel = rsVec (rsRandf (1.0f), rsRandf (1.0f), rsRandf (1.0f));
targetRadialVel.normalize ();
targetRadialVel *= float (dCameraspeed) * rsRandf (0.002f);
} else
targetRadialVel = rsVec (0.0f, 0.0f, 0.0f);
}
rsVec tempRadialVel = radialVel;
float angle = tempRadialVel.normalize ();
rsQuat radialQuat;
radialQuat.make (angle, tempRadialVel[0], tempRadialVel[1], tempRadialVel[2]);
rotQuat.preMult (radialQuat);
rsMatrix rotMat;
rotMat.fromQuat (rotQuat);
// make billboard matrix for rotating particles when they are drawn
rotMat.get (billboardMat);
// Calculate new color
static rsVec oldHsl, newHsl = rsVec (rsRandf (1.0f), 1.0f, 1.0f), targetHsl;
static float colorInterp = 1.0f, colorChange;
colorInterp += elapsedTime * colorChange;
if (colorInterp >= 1.0f) {
if (!rsRandi (3) && dIons >= 100) // change color suddenly
newHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
oldHsl = newHsl;
targetHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
colorInterp = 0.0f;
// amount by which to change colorInterp each second
colorChange = rsRandf (0.005f * float (dSpeed)) + (0.002f * float (dSpeed));
} else {
float diff = targetHsl[0] - oldHsl[0];
if (diff < -0.5f || (diff > 0.0f && diff < 0.5f))
newHsl[0] = oldHsl[0] + colorInterp * diff;
else
newHsl[0] = oldHsl[0] - colorInterp * diff;
diff = targetHsl[1] - oldHsl[1];
newHsl[1] = oldHsl[1] + colorInterp * diff;
if (newHsl[0] < 0.0f)
newHsl[0] += 1.0f;
if (newHsl[0] > 1.0f)
newHsl[0] -= 1.0f;
hsl2rgb (newHsl[0], newHsl[1], 1.0f, newRgb[0], newRgb[1], newRgb[2]);
}
// Release ions
if (ionsReleased < dIons) {
releaseTime -= elapsedTime;
while (ionsReleased < dIons && releaseTime <= 0.0f) {
ilist[ionsReleased].start ();
ionsReleased++;
// all ions released after 2 minutes
releaseTime += 120.0f / float (dIons);
}
}
// Set interpolation value for emitters and attracters
static float wait = 0.0f;
static float preinterp = PI, interp;
static float interpconst = 0.001f;
wait -= elapsedTime;
if (wait <= 0.0f) {
preinterp += elapsedTime * float (dSpeed) * interpconst;
interp = 0.5f - (0.5f * cos (preinterp));
}
if (preinterp >= PI) {
// select new taget points (not the same pattern twice in a row)
static int newTarget = 0, lastTarget;
lastTarget = newTarget;
newTarget = rsRandi (10);
if (newTarget == lastTarget)
newTarget++;
setTargets (newTarget);
preinterp = 0.0f;
interp = 0.0f;
wait = 10.0f; // pause after forming each new pattern
interpconst = 0.001f;
if (!rsRandi (4)) // interpolate really fast sometimes
interpconst = 0.1f;
}
// Update particles
for (i = 0; i < dEmitters; i++) {
elist[i].interppos (interp);
elist[i].update ();
}
for (i = 0; i < dAttracters; i++) {
alist[i].interppos (interp);
alist[i].update ();
}
for (i = 0; i < ionsReleased; i++)
ilist[i].update ();
// Calculate surface
if (dSurface) {
for (i = 0; i < dEmitters; i++)
spheres[i].setPosition (elist[i].pos[0], elist[i].pos[1], elist[i].pos[2]);
for (i = 0; i < dAttracters; i++)
spheres[dEmitters + i].setPosition (alist[i].pos[0], alist[i].pos[1], alist[i].pos[2]);
impCrawlPointVector cpv;
for(i=0; i<dEmitters+dAttracters; i++)
spheres[i].addCrawlPoint(cpv);
surface->reset ();
static float valuetrig = 0.0f;
valuetrig += elapsedTime;
volume->setSurfaceValue(0.45f + 0.05f * cosf(valuetrig));
volume->makeSurface(cpv);
}
// Draw
// clear the screen
if (dBlur) { // partially
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, 1.0, -1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.0f, 0.0f, 0.0f, 0.5f - (float(sqrtf(sqrtf(float(dBlur)))) * 0.15495f));
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
} else // completely
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw ions
glMatrixMode(GL_MODELVIEW);
glBlendFunc (GL_ONE, GL_ONE);
glBindTexture (GL_TEXTURE_2D, 1);
for (i = 0; i < ionsReleased; i++)
ilist[i].draw ();
// Draw surfaces
float brightFactor = 0;
float surfaceColor[3] = {
0.0f,
0.0f,
0.0f
};
if (dSurface) {
glBindTexture (GL_TEXTURE_2D, 2);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
// find color for surfaces
if (dIons >= 100) {
if (dWireframe)
brightFactor = 2.0f / (float (dBlur + 30) * float (dBlur + 30));
else
brightFactor = 4.0f / (float (dBlur + 30) * float (dBlur + 30));
for (i = 0; i < 100; i++) {
surfaceColor[0] += ilist[i].rgb[0] * brightFactor;
surfaceColor[1] += ilist[i].rgb[1] * brightFactor;
surfaceColor[2] += ilist[i].rgb[2] * brightFactor;
}
glColor3fv (surfaceColor);
} else {
if (dWireframe)
brightFactor = 200.0f / (float (dBlur + 30) * float (dBlur + 30));
else
brightFactor = 400.0f / (float (dBlur + 30) * float (dBlur + 30));
glColor3f (newRgb[0] * brightFactor, newRgb[1] * brightFactor, newRgb[2] * brightFactor);
}
// draw the surface
glPushMatrix ();
glMultMatrixf (billboardMat);
if (dWireframe) {
glDisable (GL_TEXTURE_2D);
surface->draw_wireframe ();
glEnable (GL_TEXTURE_2D);
} else
surface->draw ();
glPopMatrix ();
glDisable (GL_TEXTURE_GEN_S);
glDisable (GL_TEXTURE_GEN_T);
}
// If graphics card does a true buffer swap instead of a copy swap
// then everything must get drawn on both buffers
if (dBlur & pfd_swap_exchange) {
glXSwapBuffers (dpy, window);
// wglSwapLayerBuffers(hdc, WGL_SWAP_MAIN_PLANE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f (0.0f, 0.0f, 0.0f, 0.5f - (float (sqrt (sqrt (double (dBlur)))) * 0.15495f));
glPushMatrix ();
glLoadIdentity ();
glBegin (GL_TRIANGLE_STRIP);
glVertex3f (-5.0f, -4.0f, -3.0f);
glVertex3f (5.0f, -4.0f, -3.0f);
glVertex3f (-5.0f, 4.0f, -3.0f);
glVertex3f (5.0f, 4.0f, -3.0f);
glEnd ();
glPopMatrix ();
// Draw ions
glBlendFunc (GL_ONE, GL_ONE);
glBindTexture (GL_TEXTURE_2D, 1);
for (i = 0; i < ionsReleased; i++)
ilist[i].draw ();
// Draw surfaces
if (dSurface) {
glBindTexture (GL_TEXTURE_2D, 2);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
if (dIons >= 100)
glColor3fv (surfaceColor);
else
glColor3f (newRgb[0] * brightFactor, newRgb[1] * brightFactor, newRgb[2] * brightFactor);
glPushMatrix ();
glMultMatrixf (billboardMat);
if (dWireframe) {
glDisable (GL_TEXTURE_2D);
surface->draw_wireframe ();
glEnable (GL_TEXTURE_2D);
} else
surface->draw ();
glPopMatrix ();
glDisable (GL_TEXTURE_GEN_S);
glDisable (GL_TEXTURE_GEN_T);
}
}
}
void CBuilder::build(const QString &target)
{
setTargets(target);
build();
} // build
