int alphaBetaSearch( int depth, int toMove, int alpha, int beta )
{
int score, eval;
int x, y;
// 最大深さになったら局面を評価する
if( depth == MAXDEPTH )
return evaluate( rootToMove, toMove, depth );
// MaxプレイヤーとMinプレイヤーの最高評価を初期化
if( toMove == rootToMove )
score = -INFINITYVAL;
else
score = INFINITYVAL;
// Generate all the moves by putting stones of the right color on the empty squares
// 空いているマスに正しい色の石を置いて、すべての手を作成
for( x = 1; x <= BOARDSIZE; x++ )
{
for( y = 1; y <= BOARDSIZE; y++ )
{
if( gomokuBoard[ x ][ y ] == EMPTY_SQUARE )
{
gomokuBoard[ x ][ y ] = toMove;
// この手で五目並べになったかどうかをチェック
if( fiveInRowCheck( x, y, toMove ) )
{
if( rootToMove == toMove )
{
// Maxプレイヤーの五目並べ
// 手を戻す
gomokuBoard[ x ][ y ] = EMPTY_SQUARE;
// 勝ちになった手は探索の初期局面にあったので手を保存する
if( depth == 0 )
{
nextMoveX = x;
nextMoveY = y;
}
return WINNING - depth; // 浅い探索の勝ちは深い探索の勝ちより良い
}
else
{
// Minプレイヤーの五目並べ
// 手を戻す
gomokuBoard[ x ][ y ] = EMPTY_SQUARE;
return -( WINNING - depth ); // 浅い探索の勝ちは深い探索の勝ちより良い
}
}
else
{
// alpha-beta探索を再帰的に呼ぶ
eval = alphaBetaSearch( depth + 1, flip( toMove ), alpha, beta );
// 手を戻す
gomokuBoard[ x ][ y ] = EMPTY_SQUARE;
if( rootToMove == toMove )
{
// この局面はMaxプレイヤーの手番．探索の結果は現在の最大評価より高いならば最大評価を更新
if( eval > score )
{
score = eval;
// 最善手は探索の初期局面にあったので手を保存する
if( depth == 0 )
{
nextMoveX = x;
nextMoveY = y;
}
}
// Beta枝刈り
if( score >= beta )
return score;
// alphaを更新
if( score > alpha )
alpha = score;
}
else
{
// この局面はMinプレイヤーの手番．探索の結果は現在の最低評価より低いならば最低評価を更新
if( eval < score )
score = eval;
// Alpha枝刈り
if( score <= alpha )
return score;
// Betaを更新
if( beta < score )
beta = score;
}
}
}
}
}
return score;
}
const Mat& findBlobs::findCentroidGrid()
{
m_mCentroidGrid.create(m_uBlobY, m_uBlobX, CV_64FC2);
m_mCentroidGrid = 0;
Point origin = m_vCartCoord[0];
Point x1 = m_vCartCoord[1];
Point y1 = m_vCartCoord[2];
Mat mc = Mat(m_vCentroids).reshape(1).t();
//find the left top three points in the centroids.
int mind = findNearestPointInMatrix(origin, mc);
Mat cco(2, 1, mc.type());
mc.col(mind).copyTo(cco); //orgin point
DeleteOneColOfMat(mc, mind);
m_mCentroidGrid.at<Vec2d>(0, 0) = cco;
mind = findNearestPointInMatrix(x1, mc);
Mat ccx(2, 1, mc.type());
mc.col(mind).copyTo(ccx);
DeleteOneColOfMat(mc, mind);
m_mCentroidGrid.at<Vec2d>(0, 1) = ccx;
mind = findNearestPointInMatrix(y1, mc);
Mat ccy(2, 1, mc.type());
mc.col(mind).copyTo(ccy);
DeleteOneColOfMat(mc, mind);
m_mCentroidGrid.at<Vec2d>(1, 0) = ccy;
std::vector<Point> pairs;
pairs.clear();
pairs.push_back(Point(1, 2));
pairs.push_back(Point(0, 2));
pairs.push_back(Point(0, 1));
Mat co = ccx;
Mat v = co - cco;
int j = 0;
//find the first line of the centroids
for (int i = 1; i < m_uBlobX-1; i++)
{
std::vector<int> idx;
sortTheDistFromThePoint(co, mc, idx);
const int len = 6;
int tmpidx[len] = {2, 3, 4, 5, 6, 7};
int tmpCount = 0;
int tmpCountmax = len - 1;
bool ok = false;
Mat cxy;
Mat vxy;
std::vector<int> indxy;
std::vector<double> cosa;
std::vector<double> cosb;
Point pair;
int mincosind;
while (!ok)
{
cxy.create(2, 3, mc.type());
cxy = 0;
for(size_t i = 0; i < 2; i++)
{
mc.col(idx[i]).copyTo(cxy.col(i));
}
mc.col(idx[tmpidx[tmpCount]]).copyTo(cxy.col(2));
vxy = cxy - co * Mat::ones(1, cxy.cols, co.type());
computeCos(co, v, cco, cxy, vxy, pairs, cosa, cosb);
std::vector<double>::iterator minIter = std::min_element(cosa.begin(), cosa.end());
mincosind = std::distance(cosa.begin(), minIter);
indxy.clear();
if (2 == mincosind)
{
pair = pairs[mincosind];
indxy.push_back(idx[pair.x]);
indxy.push_back(idx[pair.y]);
}
else
{
pair = pairs[mincosind];
indxy.push_back(idx[pair.x]);
indxy.push_back(idx[tmpidx[tmpCount]]);
}
ok = true;
std::vector<double>::iterator maxIter = std::max_element(cosb.begin(), cosb.end());
if ( acos(*maxIter)*180/CV_PI > 25 )
{
if (tmpCount < len)
{
tmpCount += 1;
ok = false;
}
else
std::cout << "In blobsgrid: Can not find (0," << i+1 << ")" << std::endl;
}
}
Mat cxyo = cxy.clone();
cxyo.col(pair.x).copyTo(cxy.col(0));
cxyo.col(pair.y).copyTo(cxy.col(1));
cxy = cxy.t();
cxy.pop_back();
cxy = cxy.t();
Mat vxyo = vxy.clone();
vxyo.col(pair.x).copyTo(vxy.col(0));
vxyo.col(pair.y).copyTo(vxy.col(1));
vxy = vxy.t();
vxy.pop_back();
vxy = vxy.t();
Mat ll = Mat::zeros(1, 2, cxy.type());
vxy.push_back(ll);
Mat vtmp = vxy.col(0).cross(vxy.col(1));
int trueminind = pair.x;
if (vtmp.at<double>(2,0) < 0)
{
flip(vxy, vxy, 1);
flip(cxy, cxy, 1);
flip(indxy, indxy, 1);
trueminind = pair.y;
}
std::vector<double>::iterator maxIter = std::max_element(cosa.begin(), cosa.end());
int maxind = std::distance(cosa.begin(), maxIter);
if ( (*maxIter > cos(5.0/180.0*CV_PI)) && (maxind!=trueminind ))
{
Mat m1 = cxy.col(0) - cxyo.col(mincosind);
Mat m2 = m1.t() * v;
if (m2.at<double>(0,0) > 0)
{
cxyo.col(mincosind).copyTo(cxy.col(0));
if (2 == mincosind)
{
indxy[0] = idx[tmpidx[tmpCount]];
}
else
{
indxy[0] = idx[mincosind];
}
}
}
m_mCentroidGrid.at<Vec2d>(j, i+1) = cxy.col(0);
v = cxy.col(0) - co;
co = cxy.col(0);
DeleteOneColOfMat(mc, indxy[0]);
}
//find the first col of the centroids
int i = 0;
co = ccy;
v = co - cco;
for (int j = 1; j < m_uBlobY-1; j++)
{
std::vector<int> idx;
sortTheDistFromThePoint(co, mc, idx);
const int len = 6;
int tmpidx[len] = {2, 3, 4, 5, 6, 7};
int tmpCount = 0;
int tmpCountmax = len - 1;
bool ok = false;
Mat cxy;
Mat vxy;
std::vector<int> indxy;
std::vector<double> cosa;
std::vector<double> cosb;
Point pair;
int mincosind;
while (!ok)
{
cxy.create(2, 3, mc.type());
cxy = 0;
for(size_t i = 0; i < 2; i++)
{
mc.col(idx[i]).copyTo(cxy.col(i));
}
mc.col(idx[tmpidx[tmpCount]]).copyTo(cxy.col(2));
vxy = cxy - co * Mat::ones(1, cxy.cols, co.type());
computeCos(co, v, cco, cxy, vxy, pairs, cosa, cosb);
std::vector<double>::iterator minIter = std::min_element(cosa.begin(), cosa.end());
mincosind = std::distance(cosa.begin(), minIter);
indxy.clear();
if (2 == mincosind)
{
pair = pairs[mincosind];
indxy.push_back(idx[pair.x]);
indxy.push_back(idx[pair.y]);
}
else
{
pair = pairs[mincosind];
indxy.push_back(idx[pair.x]);
indxy.push_back(idx[tmpidx[tmpCount]]);
}
ok = true;
std::vector<double>::iterator maxIter = std::max_element(cosb.begin(), cosb.end());
if ( *maxIter < cos(30.0/180.0*CV_PI) )
{
if (tmpCount < len)
{
tmpCount += 1;
ok = false;
}
else
std::cout << "In blobsgrid: Can not find (" << j+1 << ",0)" << std::endl;
}
}
Mat cxyo = cxy.clone();
cxyo.col(pair.x).copyTo(cxy.col(0));
cxyo.col(pair.y).copyTo(cxy.col(1));
cxy = cxy.t();
cxy.pop_back();
cxy = cxy.t();
Mat vxyo = vxy.clone();
vxyo.col(pair.x).copyTo(vxy.col(0));
vxyo.col(pair.y).copyTo(vxy.col(1));
vxy = vxy.t();
vxy.pop_back();
vxy = vxy.t();
Mat ll = Mat::zeros(1, 2, cxy.type());
vxy.push_back(ll);
Mat vtmp = vxy.col(0).cross(vxy.col(1));
int trueminind = pair.x;
if (vtmp.at<double>(2,0) > 0)
{
flip(vxy, vxy, 1);
flip(cxy, cxy, 1);
flip(indxy, indxy, 1);
trueminind = pair.y;
}
std::vector<double>::iterator maxIter = std::max_element(cosa.begin(), cosa.end());
int maxind = std::distance(cosa.begin(), maxIter);
if ( (*maxIter > cos(5.0/180.0*CV_PI)) && (maxind!=trueminind ))
{
Mat m1 = cxy.col(0) - cxyo.col(mincosind);
Mat m2 = m1.t() * v;
if (m2.at<double>(0,0) > 0)
{
cxyo.col(mincosind).copyTo(cxy.col(0));
if (2 == mincosind)
{
indxy[0] = idx[tmpidx[tmpCount]];
}
else
{
indxy[0] = idx[mincosind];
}
}
}
m_mCentroidGrid.at<Vec2d>(j+1, i) = cxy.col(0);
v = cxy.col(0) - co;
co = cxy.col(0);
DeleteOneColOfMat(mc, indxy[0]);
}
double costol = cos(30.0/180.0*CV_PI);
for (int j = 1; j < m_uBlobY; j++)
{
for (int i = 1; i < m_uBlobX; i++)
{
if ((i==m_uBlobX-1) && (j==m_uBlobX-1))
{
m_mCentroidGrid.at<Vec2d>(j, i) = mc.col(0);
}
else
{
Mat leftTopMat;
std::vector<int> sind;
int size[2] = {3, 2};
Vec2d v1 = m_mCentroidGrid.at<Vec2d>(j-1, i-1);
Vec2d v2 = m_mCentroidGrid.at<Vec2d>(j-1, i);
Vec2d v3 = m_mCentroidGrid.at<Vec2d>(j, i-1);
leftTopMat.push_back(v1);
leftTopMat.push_back(v2);
leftTopMat.push_back(v3);
leftTopMat = leftTopMat.reshape(1).t();
sind.clear();
sortTheDistFromThreePoint(leftTopMat, mc, sind);
Mat cclose;
if (sind.size() > 2)
{
cclose.create(2, 3, mc.type());
cclose = 0;
for(size_t i = 0; i < 3; i++)
{
mc.col(sind[i]).copyTo(cclose.col(i));
}
}
else
{
cclose.create(2, 2, mc.type());
cclose = 0;
for(size_t i = 0; i < 2; i++)
{
mc.col(sind[i]).copyTo(cclose.col(i));
}
}
Vec2d v = v2 - v1;
Mat mv3(v3);
Mat vs = mv3 * Mat::ones(1, cclose.cols, mc.type());
subtract(cclose, vs, vs);
std::vector<double> cosa;
cosa.clear();
for (int k = 0; k < cclose.cols; k++)
{
Mat tmp = Mat(v).t() * vs.col(k);
double tcos = tmp.at<double>(0,0) / (norm(v)*norm(vs.col(k)));
cosa.push_back(tcos);
}
std::vector<double>::iterator maxIter = std::max_element(cosa.begin(), cosa.end());
int maxind = std::distance(cosa.begin(), maxIter);
int minind = 0;
if (cosa[0] > costol)
{
minind = sind[0];
}
else if (cosa[0] < costol && cosa[1] > costol)
{
minind = sind[1];
}
else
{
minind = sind[maxind];
}
m_mCentroidGrid.at<Vec2d>(j, i) = mc.col(minind);
DeleteOneColOfMat(mc, minind);
}
}
}
std::string centXMLFileName = m_sSubDirectory + "\\" + m_sImageFileName + "_centroidsGrid.xml";
cv::FileStorage fs(centXMLFileName, cv::FileStorage::WRITE);
fs << "centroidsGridMat" << m_mCentroidGrid;
fs.release();
return m_mCentroidGrid;
}
void videoThread::run()
{
runFlag = 1;
while(runFlag)
{
QString result = "ok";
cap>>inputMat;
flip(inputMat,inputMat,1);
if(inputMat.data)
{
Mat objDetectMat;
objectDetect->process(inputMat,objDetectMat);
resize(objDetectMat,*objMatPtr,Size(320,240));
cvtColor(*objMatPtr,*objMatPtr,CV_BGR2RGB);
cv::cvtColor(inputMat,rgbMat,CV_BGR2RGB);
detect->setMatToDetect(rgbMat);
detect->detectAllFeatures();
rgbMat.copyTo(outMat);
locateFace();
if(collectMode)
{
collectAndTrainFace();
}
else
{
recognize();
}
static int eyeFlag = 0;
static float scale = 0.5;
if( eyeFlag == 0 )
{
scale -= 0.1;
if(scale <= 0)
{
eyeFlag = 1;
}
}
else
{
scale += 0.1;
if(scale > 0.8)
{
eyeFlag = 0;
}
}
if(FINDBALL)
{
ballFinder.setImg(inputMat);
Point center = ballFinder.findColor(detectH,detectS,detectV);
circle(outMat,center,30,Scalar(100,200,30),2);
float x_ratio = float(center.x)/inputMat.cols;
float y_ratio = float(center.y)/inputMat.rows;
emit resultReady(x_ratio,y_ratio);
}
else
{
emit resultReady(QString(showMessage.data()));
}
}
}
}
NxU32 readDword(bool mismatch, const NxStream& stream)
{
NxU32 d = stream.readDword();
if(mismatch) d = flip(&d);
return d;
}
void writeDword(NxU32 value, bool mismatch, NxStream& stream)
{
if(mismatch) value = flip(&value);
stream.storeDword(value);
}
// Initilize and rsx
void init_screen(int command_buffer, int z_method) {
// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
void *host_addr = memalign(1024*1024, command_buffer);
assert(host_addr != NULL);
if(z_method) zformat = REALITY_TARGET_FORMAT_ZETA_Z24S8; else zformat = REALITY_TARGET_FORMAT_ZETA_Z16;
// Initilise Reality, which sets up the command buffer and shared IO memory
context = rsxInit(0x10000, command_buffer, host_addr);
assert(context != NULL);
videoState state;
assert(videoGetState(0, 0, &state) == 0); // Get the state of the display
assert(state.state == 0); // Make sure display is enabled
// Get the current resolution
assert(videoGetResolution(state.displayMode.resolution, &Video_Resolution) == 0);
Video_pitch = 4 * ((Video_Resolution.width + 15)/16) * 16; // each pixel is 4 bytes
if(!z_method)
// 16 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 2 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+31)/32)*32) : 1920);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 4 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+15)/16)*16) : 1920);
// Configure the buffer format to xRGB
videoConfiguration vconfig;
memset(&vconfig, 0, sizeof(videoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = Video_pitch;
Video_aspect=vconfig.aspect=state.displayMode.aspect;
assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
assert(videoGetState(0, 0, &state) == 0);
s32 buffer_size = Video_pitch * Video_Resolution.height;
s32 depth_buffer_size;
if(!z_method)
// 16 bit float. Note it uses 1088 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+31)/32)*32) : 1088);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+15)/16)*16) : 1088);
printf("buffers will be 0x%x bytes\n", buffer_size);
gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip
// Allocate two buffers for the RSX to draw to the screen (double buffering)
Video_buffer[0] = rsxMemalign(64, buffer_size);
Video_buffer[1] = rsxMemalign(64, buffer_size);
assert(Video_buffer[0] != NULL && Video_buffer[1] != NULL);
depth_buffer = rsxMemalign(64, depth_buffer_size);
assert(rsxAddressToOffset(Video_buffer[0], &offset[0]) == 0);
assert(rsxAddressToOffset(Video_buffer[1], &offset[1]) == 0);
// Setup the display buffers
assert(gcmSetDisplayBuffer(0, offset[0], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(gcmSetDisplayBuffer(1, offset[1], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(rsxAddressToOffset(depth_buffer, &depth_offset) == 0);
gcmResetFlipStatus();
flip(1);
waitFlip();
}
s32 main(s32 argc, const char* argv[])
{
printf("init_screen()\n");
init_screen();
PadInfo padinfo;
PadData paddata;
int i;
printf("Initializing 6 SPUs... ");
printf("%08x\n", lv2SpuInitialize(6, 5));
printf("ioPadInit()\n");
ioPadInit(7);
printf("init_efb()\n");
init_efb(1);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
u64 frameStart=sys_time_get_system_time();
printf("frame\n");
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS){
return 0;
}
}
}
u64 afterPad=sys_time_get_system_time();
u64 afterWaitForBlit=sys_time_get_system_time();
printf("waitFlip\n");
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
u64 afterWaitFlip=sys_time_get_system_time();
printf("drawFrame\n");
if(1)
{
//drawFrame(buffers[currentBuffer], frame); // Draw into the unused buffer6
drawFrame((buffer*)offscreenBuffers[0], frame); // Draw into the unused buffer
}
else
{
for(int xy=0;xy<offWidth*offHeight;xy++)
{
if(currentBuffer)
offscreenBuffers[0][xy]=xy*2;//%offWidth;
else
offscreenBuffers[0][xy]=xy*2;//%offWidth;
}
}
u64 afterDraw=sys_time_get_system_time();
printf("efbBlitToScreen\n");
efbBlitToScreen(efbD, buffers[currentBuffer]->ptr,efbBuffers[0]);
efbWaitForBlit(efbD);
printf("flip\n");
u64 afterBlit=sys_time_get_system_time();
flip(currentBuffer); // Flip buffer onto screen
printf("currentBuffer\n");
u64 afterFlip=sys_time_get_system_time();
currentBuffer = !currentBuffer;
frame++;
//if(frame>4)
// break;
u64 padTime=afterPad-frameStart;
u64 blitFlipWaitTime=afterWaitForBlit-afterPad;
u64 flipWaitTime=afterWaitFlip-afterWaitForBlit;
u64 drawTime=afterDraw-afterWaitFlip;
u64 blitTime=afterBlit-afterDraw;
u64 flipTime=afterFlip-afterBlit;
u64 totalTime=afterFlip-frameStart;
printf("%9ld, %9ld, %9ld, %9ld, %9ld, %9ld, %9ld\n",padTime,blitFlipWaitTime,flipWaitTime,drawTime,blitTime,flipTime,totalTime);
//break;
}
efbShutdown(efbD);
return 0;
}
void ProcessingThread::run()
{
while(1)
{
/////////////////////////////////
// Stop thread if stopped=TRUE //
/////////////////////////////////
stoppedMutex.lock();
if (stopped)
{
stopped=false;
stoppedMutex.unlock();
break;
}
stoppedMutex.unlock();
/////////////////////////////////
/////////////////////////////////
// Save processing time
processingTime=t.elapsed();
// Start timer (used to calculate processing rate)
t.start();
// Get frame from queue, store in currentFrame, set ROI
currentFrame=Mat(imageBuffer->getFrame(),currentROI);
updateMembersMutex.lock();
///////////////////
// PERFORM TASKS //
///////////////////
// Note: ROI changes will take effect on next frame
if(resetROIFlag)
resetROI();
else if(setROIFlag)
setROI();
////////////////////////////////////
// PERFORM IMAGE PROCESSING BELOW //
////////////////////////////////////
// Grayscale conversion
if(grayscaleOn)
cvtColor(currentFrame,currentFrameGrayscale,CV_BGR2GRAY);
// Smooth (in-place operations)
if(smoothOn)
{
if(grayscaleOn)
{
switch(smoothType)
{
// BLUR
case 0:
blur(currentFrameGrayscale,currentFrameGrayscale,Size(smoothParam1,smoothParam2));
break;
// GAUSSIAN
case 1:
GaussianBlur(currentFrameGrayscale,currentFrameGrayscale,Size(smoothParam1,smoothParam2),smoothParam3,smoothParam4);
break;
// MEDIAN
case 2:
medianBlur(currentFrameGrayscale,currentFrameGrayscale,smoothParam1);
break;
}
}
else
{
switch(smoothType)
{
// BLUR
case 0:
blur(currentFrame,currentFrame,Size(smoothParam1,smoothParam2));
break;
// GAUSSIAN
case 1:
GaussianBlur(currentFrame,currentFrame,Size(smoothParam1,smoothParam2),smoothParam3,smoothParam4);
break;
// MEDIAN
case 2:
medianBlur(currentFrame,currentFrame,smoothParam1);
break;
}
}
}
// Dilate
if(dilateOn)
{
if(grayscaleOn)
dilate(currentFrameGrayscale,currentFrameGrayscale,Mat(),Point(-1,-1),dilateNumberOfIterations);
else
dilate(currentFrame,currentFrame,Mat(),Point(-1,-1),dilateNumberOfIterations);
}
// Erode
if(erodeOn)
{
if(grayscaleOn)
erode(currentFrameGrayscale,currentFrameGrayscale,Mat(),Point(-1,-1),erodeNumberOfIterations);
else
erode(currentFrame,currentFrame,Mat(),Point(-1,-1),erodeNumberOfIterations);
}
// Flip
if(flipOn)
{
if(grayscaleOn)
flip(currentFrameGrayscale,currentFrameGrayscale,flipCode);
else
flip(currentFrame,currentFrame,flipCode);
}
// Canny edge detection
if(cannyOn)
{
// Frame must be converted to grayscale first if grayscale conversion is OFF
if(!grayscaleOn)
cvtColor(currentFrame,currentFrameGrayscale,CV_BGR2GRAY);
Canny(currentFrameGrayscale,currentFrameGrayscale,
cannyThreshold1,cannyThreshold2,
cannyApertureSize,cannyL2gradient);
}
////////////////////////////////////
// PERFORM IMAGE PROCESSING ABOVE //
////////////////////////////////////
// Convert Mat to QImage: Show grayscale frame [if either Grayscale or Canny processing modes are ON]
if(grayscaleOn||cannyOn)
frame=MatToQImage(currentFrameGrayscale);
// Convert Mat to QImage: Show BGR frame
else
frame=MatToQImage(currentFrame);
updateMembersMutex.unlock();
// Update statistics
updateFPS(processingTime);
currentSizeOfBuffer=imageBuffer->getSizeOfImageBuffer();
// Inform GUI thread of new frame (QImage)
emit newFrame(frame);
}
qDebug() << "Stopping processing thread...";
}
int main()
{ finit( 9, 9, 0, 3);
int n; /* having a spare int is useful. */
time_t t;
printw(
" This game is so interesting and meaningfull\n"
"and the reasons why are explained in this message...\n"
"...which may or may not be complete\n"
"\n"
"(press any 3 keys to continue)\n");
getch();
getch();
getch();
clear();
#include "objects.h"
while(loop)
{
switch(z)
{
case 0:
uroom[0]=5;
wroom[0]=1;
wall=
"Some sort of wall mesage should be displayed here,\n"
"It should inform the player of the solidity of this wall,\n"
"and it should warn that attempts to surpass this fact are admonishable.";
event(11,11,30,"hello");
event(11,11,31,"hello again");
event(11,11,32,"hello a third time");
mesage[0][0].x =12;
mesage[0][0].y =12;
mesage[0][0].ch='*';
mesage[0][0].hit="Hello sir, this is a structure mesage";
msg(8,9,
"THIS SPOT IS IMPORTANT FOR THIS REASON");
smsg(2,9,
" This spot is UBER important :)\n"
"It clears the screen to show you something!!!! \n");
smsg(2,9,
" And it can do it twice!!!\n");
smsg(2,9,
"\n"
"And thrice as well!!! :)");
if(sw[0])
{
smsg(9,9,
"This is a new stairwell.");
}
break;
case 1:
wall=
"this is a wall in room 1";
droom[1]=2;
eroom[1]=0;
sroom[1]=4;
break;
case 2:
wall=
"this is a more interesting wall in room 2";
sroom[2]=3;
uroom[2]=1;
break;
case 3:
wall=
"in room 3, the wall is so interesting, it's unsurpassable...";
nroom[3]=2;
break;
case 4:
wall=
"...when it's not compared to these walls in room 4\n"
"(see room 3's walls)";
smsg(6,14,
" this is an object of\n"
"INSURMOUNTABLE POWER...\n"
"It will somehow help you on your\n"
"QUEST,\n"
"(which has neither been defined nor\n"
"ACCEPTED)...\n"
"\n"
"...once the master programmer imbues\n"
"it with the power to do such.\n"
"\n"
"Until then, walk from here back to\n"
"THE BEGINING,\n"
"and from there to here 9 times 7.\n"
"\n");
smsg(6,14,
"+-----------------------------------+"
"| |"
"| |"
"| ???? |"
"| ?? ? ??? |"
"| ?? ?? |"
"| #### ? #### |"
"| ### ## ? ## ## |"
"| ## ? # ? ## |"
"| ## ? o ? ## |"
"| ## ? # ? ## |"
"| ## ## ? ## ### |"
"| #### ? #### |"
"| ?? ?? |"
"| ??? ? ?? |"
"| ???? |"
"| |"
"| |"
"+-----------------------------------+");
smsg(6,14,
" The Master Programmer hath spoken."
"He hath declared that the way forth "
"shall become clear if you retrace "
"your steps to your point of origin. ");
lvr(6,14,0);
if(sw[0]==1)
{
map[0][9][9]='^';
sw[0]==2;
}
nroom[4]=1;
break;
case 5:
wall=
"there is nothing extra-ordinary about these walls";
droom[5]=0;
nroom[5]=6;
smsg(9,8,
"\n\n\n Time:\n"
"all encompasing,\n"
"inescapable...\n");
smsg(9,1,
"\n\n\n...incorporeal.\n\n"
" In Time\n" /* "Time" which refers to the clock, is a proper noun in this case*/
"The Trinity will point forward...");
lvr(9 , 4,1);
lvr(13, 5,2);
lvr(14,9 ,3);
lvr(13,13,4);
lvr(9 ,14,5);
lvr(5 ,13,6);
lvr(4 , 9,7);
lvr(5 , 5,8);
if(sw[1]&&sw[3]&&sw[5]&&sw[7]||sw[2]&&sw[4]&&sw[6]&&sw[8])
{
sw[1]=0;
sw[2]=0;
sw[3]=0;
sw[4]=0;
sw[5]=0;
sw[6]=0;
sw[7]=0;
sw[8]=0;
}
if(sw[1]&&sw[4]&&sw[6]||sw[2]&&sw[5]&&sw[7]||sw[8]&&sw[5]&&sw[3])
{
map[5][0][ 8]=' ';
map[5][0][ 9]=' ';
map[5][0][10]=' ';
}
else
{
map[5][0][ 8]='-';
map[5][0][ 9]='-';
map[5][0][10]='-';
}
if(time(NULL)>t)
{
int a,b,c,d,e,f,g,h;
a=sw[1]; //rotate lvrs
b=sw[2];
c=sw[3];
d=sw[4];
e=sw[5];
f=sw[6];
g=sw[7];
h=sw[8];
sw[1]=h;
sw[2]=a;
sw[3]=b;
sw[4]=c;
sw[5]=d;
sw[6]=e;
sw[7]=f;
sw[8]=g;
}
t=time(NULL);
break;
case 6:
sroom[6]=5;
uroom[6]=7;
map[5][0][ 8]=' ';
map[5][0][ 9]=' ';
map[5][0][10]=' ';
msg( 9, 9,
"...all will be of one substance...");
lvr( 6, 6, 9);
lvr(12, 6,10);
lvr( 9, 7,11);
lvr( 7, 9,12);
lvr(11, 9,13);
lvr( 9,11,14);
lvr( 6,12,15);
lvr(12,12,16);
if(sw[ 9]==1)
{
flip(13);
flip(14);
sw[ 9]=2;
}
if(sw[10]==1)
{
flip(12);
flip(14);
sw[10]=2;
}
if(sw[11]==1)
{
flip(15);
flip(16);
sw[11]=2;
}
if(sw[12]==1)
{
flip(10);
flip(16);
sw[12]=2;
}
if(sw[13]==1)
{
flip( 9);
flip(15);
sw[13]=2;
}
if(sw[14]==1)
{
flip( 9);
flip(10);
sw[14]=2;
}
if(sw[15]==1)
{
flip(13);
flip(11);
sw[15]=2;
}
if(sw[16]==1)
{
flip(11);
flip(12);
sw[16]=2;
}
lvr( 6, 6, 9);
lvr(12, 6,10);
lvr( 9, 7,11);
lvr( 7, 9,12);
lvr(11, 9,13);
lvr( 9,11,14);
lvr( 6,12,15);
lvr(12,12,16);
if(sw[9]&&sw[10]&&sw[11]&&sw[12]&&sw[13]&&sw[14]&&sw[15]&&sw[16])
{map[6][9][9]='^';}
break;
case 7:
uroom[7]=8;
droom[7]=6;
lvr( 5, 5,17);
lvr(13, 5,18);
lvr(13,13,19);
lvr(5 ,13,20);
for(n=17;n<20;n++)
{
if(sw[n]==1)
{
flip(n+4);
flip(n+1);
flip(n);
}
}
if(sw[20]==1)
{
flip(17);
flip(24);
flip(20);
}
mlvr( 5, 5,17);
mlvr(13, 5,18);
mlvr(13,13,19);
mlvr(5 ,13,20);
break;
case 8:
uroom[8]=9;
droom[8]=7;
lvr( 9, 9,30);
lvr( 5, 5,21);
lvr(13, 5,22);
lvr(13,13,23);
lvr(5 ,13,24);
for(n=22;n<=24;n++)
{
if(sw[n]==1)
{
flip(n-1);
flip(n+4);
flip(n-4);
flip(n);
}
}
if(sw[21]==1)
{
flip(24);
flip(25);
flip(17);
flip(21);
}
if(sw[30]==1)
{
int a,b,c,d;
a=sw[21];
b=sw[22];
c=sw[23];
d=sw[24];
sw[21]=b;
sw[22]=c;
sw[23]=d;
sw[24]=a;
flip(30);
}
mlvr( 9, 9,30);
mlvr( 5, 5,21);
mlvr(13, 5,22);
mlvr(13,13,23);
mlvr(5 ,13,24);
break;
case 9:
droom[9]=8;
uroom[9]=10;
lvr( 9, 9,29);
lvr( 5, 5,25);
lvr(13, 5,26);
lvr(13,13,27);
lvr(5 ,13,28);
for(n=25;n<28;n++)
{
if(sw[n]==1)
{
flip(n+1);
flip(n-4);
flip(n);
}
}
if(sw[28]==1)
{
flip(25);
flip(24);
flip(28);
}
if(sw[29]==1)
{
int a,b,c,d;
a=sw[25];
b=sw[26];
c=sw[27];
d=sw[28];
sw[25]=d;
sw[26]=a;
sw[27]=b;
sw[28]=c;
flip(29);
}
mlvr( 5, 5,25);
mlvr(13, 5,26);
mlvr(13,13,27);
mlvr(5 ,13,28);
break;
default:
endwin();
printf("ERROR THE PROGGRAMMER HAS YET TO MAKE THIS LEVEL!!!\n");
loop=0;
return 1;
}
mesages();
levers();
BlockMessage();
uncover(1);
showmap();
input();
}
endwin();
return 0;
}
QPixmap Images::flippedIcon(QString name, int size, bool png) {
QPixmap p = icon(name, size, png);
p = flip(&p);
return p;
}
int main(int argc, char **argv)
#endif
{
bool pkg_installed = false;
#if DEBUG
debug_wait_for_client();
#endif
#ifdef __POWERPC__
addr = 0x4c490d03;
host = "pkg-distro.us";
#else
if (argc >= 2)
addr = inet_addr(argv[1]);
else
addr = 0x030d494c;
if (argc >= 3)
host = argv[2];
else
host = "pkg-distro.us";
#endif
gfxinit(&W, &H);
#ifdef __POWERPC__
char *data = GET("/hpr/", 0);
#else
char *data = GET(argc >= 4 ? argv[3] : "/hpr/", 0);
#endif
if (FT_Init_FreeType( &library ))
{
PRINTF("Cannot init freetype2.\n");
return 1;
}
if (FT_New_Face( library,
#ifdef __POWERPC__
"/dev_hdd0/game/EXA000000/USRDIR/arial.ttf",
#else
"arial.ttf",
#endif
0,
&face ))
{
PRINTF("Cannot load font.\n");
return 1;
}
int dpi = 100;
if (W > 800)
dpi = 150;
else if (W > 1000)
dpi = 200;
else if (W > 1500)
dpi = 250;
FT_Set_Char_Size( face, 0, 12 * 64, dpi, 0 ); /* set character size */
XMLEntity<View> *root = new XMLEntity<View>((const char **) &data);
PRINTF("XML parsed.\n");
View *view = new View(*root);
PRINTF("View ready.\n");
waitFlip();
view->render();
copy();
flip();
PRINTF("Render ok.\n");
bool running = true;
PRINTF("In main loop.\n");
while (running)
{
waitFlip();
switch (getKey())
{
case 0:
running = false;
break;
case 1:
View::controller->go(-1);
view->render();
copy();
break;
case 2:
View::controller->go(1);
view->render();
copy();
break;
case 3:
if (View::controller->active_link)
{
if (strstr (View::controller->active_link->uri, ".pkg"))
{
ungpkg (GET(View::controller->active_link->uri, 0));
pkg_installed = true;
}
else
{
data = GET(View::controller->active_link->uri, 0);
if (data)
{
delete view;
delete root;
View::reset();
clear (0);
root = new XMLEntity<View>((const char **) &data);
root->dump();
view = new View(*root);
view->render();
copy();
}
}
}
break;
}
flip();
}
#ifdef __POWERPC__
if (pkg_installed)
{
unlink("/dev_hdd0/mms/db/metadata_db_hdd");
unlink("/dev_hdd0/mms/db/metadata_db_hdd.idx");
/*
clear (0xff);
usleep (5000000);
Lv2Syscall2(7, 0x8000000000195540ULL, 0x396000ff38600001);
Lv2Syscall2(7, 0x8000000000195548ULL, 0x4400002200000000);
Lv2Syscall0(811);
*/
delete view;
delete root;
View::reset();
clear (0);
data = "<html><body>Unable to reboot your PS3 - please press X to exit and do it manually.</body></html>";
root = new XMLEntity<View>((const char **) &data);
root->dump();
view = new View(*root);
view->render();
copy();
while (getKey() != 3)
{
waitFlip();
flip();
}
}
#endif
return 0;
}
void Objectness::generateTrianData()
{
const int NUM_TRAIN = _voc.trainNum;
const int FILTER_SZ = _W*_W;
vector<vector<Mat> > xTrainP(NUM_TRAIN), xTrainN(NUM_TRAIN);
vector<vecI> szTrainP(NUM_TRAIN); // Corresponding size index.
const int NUM_NEG_BOX = 100; // Number of negative windows sampled from each image
#pragma omp parallel for
for (int i = 0; i < NUM_TRAIN; i++) {
const int NUM_GT_BOX = (int)_voc.gtTrainBoxes[i].size();
vector<Mat> &xP = xTrainP[i], &xN = xTrainN[i];
vecI &szP = szTrainP[i];
xP.reserve(NUM_GT_BOX*4), szP.reserve(NUM_GT_BOX*4), xN.reserve(NUM_NEG_BOX);
Mat im3u = imread(format(_S(_voc.imgPathW), _S(_voc.trainSet[i])));
// Get positive training data
for (int k = 0; k < NUM_GT_BOX; k++) {
const Vec4i& bbgt = _voc.gtTrainBoxes[i][k];
vector<Vec4i> bbs; // bounding boxes;
vecI bbR; // Bounding box ratios
int nS = gtBndBoxSampling(bbgt, bbs, bbR);
for (int j = 0; j < nS; j++) {
bbs[j][2] = min(bbs[j][2], im3u.cols);
bbs[j][3] = min(bbs[j][3], im3u.rows);
Mat mag1f = getFeature(im3u, bbs[j]), magF1f;
flip(mag1f, magF1f, CV_FLIP_HORIZONTAL);
xP.push_back(mag1f);
xP.push_back(magF1f);
szP.push_back(bbR[j]);
szP.push_back(bbR[j]);
}
}
// Get negative training data
for (int k = 0; k < NUM_NEG_BOX; k++) {
int x1 = rand() % im3u.cols + 1, x2 = rand() % im3u.cols + 1;
int y1 = rand() % im3u.rows + 1, y2 = rand() % im3u.rows + 1;
Vec4i bb(min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2));
if (maxIntUnion(bb, _voc.gtTrainBoxes[i]) < 0.5)
xN.push_back(getFeature(im3u, bb));
}
}
const int NUM_R = _numT * _numT + 1;
vecI szCount(NUM_R); // Object counts of each size (combination of scale and aspect ratio)
int numP = 0, numN = 0, iP = 0, iN = 0;
for (int i = 0; i < NUM_TRAIN; i++) {
numP += xTrainP[i].size();
numN += xTrainN[i].size();
const vecI &rP = szTrainP[i];
for (size_t j = 0; j < rP.size(); j++)
szCount[rP[j]]++;
}
vecI szActive; // Indexes of active size
for (int r = 1; r < NUM_R; r++) {
if (szCount[r] > 50) // If only 50- positive samples at this size, ignore it.
szActive.push_back(r-1);
}
matWrite(_modelName + ".idx", Mat(szActive));
Mat xP1f(numP, FILTER_SZ, CV_32F), xN1f(numN, FILTER_SZ, CV_32F);
for (int i = 0; i < NUM_TRAIN; i++) {
vector<Mat> &xP = xTrainP[i], &xN = xTrainN[i];
for (size_t j = 0; j < xP.size(); j++)
memcpy(xP1f.ptr(iP++), xP[j].data, FILTER_SZ*sizeof(float));
for (size_t j = 0; j < xN.size(); j++)
memcpy(xN1f.ptr(iN++), xN[j].data, FILTER_SZ*sizeof(float));
}
CV_Assert(numP == iP && numN == iN);
matWrite(_modelName + ".xP", xP1f);
matWrite(_modelName + ".xN", xN1f);
}
void PS3_renderFrame(int sync) {
drawFrame();
flip(sync);
}
void WebcamHandler::run()
{
// initialize webcam
VideoCapture cap = VideoCapture(0);
cap.set(CV_CAP_PROP_FRAME_WIDTH, m_frameWidth);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, m_frameHeight);
// initialize window
namedWindow("Settings", CV_WINDOW_AUTOSIZE);
namedWindow("FaceRepair", CV_WINDOW_NORMAL);
cvSetWindowProperty("FaceRepair", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
cvWaitKey(1000);
float* hidden;
float* visible;
while (m_loop)
{
// read frame and continue with next frame if not successfull
Mat frame;
cap.retrieve(frame);
flip(frame, frame, 1);
// take subimage at faceArea
Mat subimage;
frame(*m_faceArea).copyTo(subimage);
Mat subimageHSV;
cvtColor(subimage, subimageHSV, COLOR_BGR2HSV); //Convert the captured frame from BGR to HSV
// detect color
Mat mask;
inRange(subimageHSV, *m_detectionColorMin, *m_detectionColorMax, mask);
erode(mask, mask, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)));
dilate(mask, mask, getStructuringElement(MORPH_ELLIPSE, Size(15, 15)));
Mat invertedMask = 255 - mask;
// scale to rbm input size
Size size = Size(m_edgeLength, m_edgeLength);
Mat scaledSubimage;
resize(subimage, scaledSubimage, size, 0.0, 0.0, INTER_LINEAR);
Mat scaledMask;
resize(mask, scaledMask, size, 0.0, 0.0, INTER_NEAREST);
Mat invertedScaledMask = 255 - scaledMask;
// calc mean rgb of preserved area
Scalar bgr = mean(scaledSubimage, invertedScaledMask);
// set mean rgb at reconstructionArea
scaledSubimage.setTo(bgr, scaledMask);
// subimage to normalized float array
visible = matToNormalizedFloatArrayWithBias(&scaledSubimage);
// process RBMs
hidden = m_rbm1000->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm1000->runVisible(hidden, 1);
delete hidden;
visible[0] = 1;
resetPreservedArea(&scaledSubimage, &invertedScaledMask, visible);
hidden = m_rbm1500->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm1500->runVisible(hidden, 1);
delete hidden;
visible[0] = 1;
resetPreservedArea(&scaledSubimage, &invertedScaledMask, visible);
hidden = m_rbm2000->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm2000->runVisible(hidden, 1);
delete hidden;
// normalized float array to subimage
normalizedFloatArrayToMatWithoutBias(visible, &scaledSubimage);
// scale to original faceArea size
Mat result;
size = Size(m_faceArea->width, m_faceArea->height);
resize(scaledSubimage, result, size, 0.0, 0.0, INTER_CUBIC);
// reset pixels of preserved area in native resolution
subimage.copyTo(result, invertedMask);
// create fullscreen image
Mat fs;
frame.copyTo(fs);
result.copyTo(fs(*m_faceArea));
flip(fs, fs, 1);
// maybe not necessary
//result.copyTo(frame(*m_faceArea));
// paint visualizations for settings image
rectangle(frame, *m_faceArea, Scalar(0, 255, 0));
Point* eyePositions = calculateEyePositions(m_faceArea, m_relativeEyePositionX, m_relativeEyePositionY);
circle(frame, eyePositions[0], 4, Scalar(255, 255, 0));
circle(frame, eyePositions[1], 4, Scalar(255, 255, 0));
delete eyePositions;
// show frames
imshow("Settings", frame);
imshow("FaceRepair", fs);
// check keyboard input
checkKeys();
}
// terminate webcam
cap.release();
}
BoardSetupDialog::BoardSetupDialog(QWidget* parent, Qt::WindowFlags f) : QDialog(parent, f),
m_wheelCurrentDelta(0), m_selectedPiece(Empty), inDrag(false)
{
setObjectName("BoardSetupDialog");
ui.setupUi(this);
QPushButton *pasteButton = ui.buttonBox->addButton(tr("Paste FEN"), QDialogButtonBox::ActionRole);
copyButton = ui.buttonBox->addButton(tr("Copy FEN"), QDialogButtonBox::ApplyRole);
btCopyText = ui.buttonBox->addButton(tr("Copy Text"), QDialogButtonBox::ApplyRole);
restoreLayout();
ui.boardView->configure();
ui.boardView->setFlags(BoardView::IgnoreSideToMove | BoardView::SuppressGuessMove | BoardView::AllowCopyPiece);
ui.boardView->showMoveIndicator(false);
ui.boardView->showCoordinates(true);
m_minDeltaWheel = AppSettings->getValue("/Board/minWheelCount").toInt();
for(int piece = Empty; piece <= BlackPawn; piece++)
{
BoardSetupToolButton* button = new BoardSetupToolButton(this);
button->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
button->setMinimumSize(QSize(10, 10));
button->m_piece = (Piece)piece;
if(piece == Empty)
{
button->m_pixmap = QPixmap(0, 0);
ui.buttonLayout->addWidget(button, 6, 0);
}
else
{
button->m_pixmap = ui.boardView->theme().piece(Piece(piece));
ui.buttonLayout->addWidget(button, (piece - 1) % 6, piece >= BlackKing);
}
connect(button, SIGNAL(signalDragStarted(QWidget*, QMouseEvent*)), this, SLOT(startDrag(QWidget*, QMouseEvent*)));
connect(button, SIGNAL(signalClicked(Piece)), this, SLOT(labelClicked(Piece)));
connect(this, SIGNAL(signalClearBackground(Piece)), button, SLOT(slotClearBackground(Piece)));
}
emit signalClearBackground(Empty);
ui.buttonBoxTools->button(QDialogButtonBox::RestoreDefaults)->setText(tr("Clear"));
connect(ui.buttonBoxTools->button(QDialogButtonBox::RestoreDefaults), SIGNAL(clicked()), SLOT(slotClear()));
connect(ui.buttonBoxTools->button(QDialogButtonBox::Reset), SIGNAL(clicked()), SLOT(slotReset()));
connect(ui.boardView, SIGNAL(clicked(Square, int, QPoint, Square)), SLOT(slotSelected(Square, int)));
connect(ui.boardView, SIGNAL(moveMade(Square, Square, int)), SLOT(slotMovePiece(Square, Square)));
connect(ui.boardView, SIGNAL(copyPiece(Square, Square)), SLOT(slotCopyPiece(Square, Square)));
connect(ui.boardView, SIGNAL(invalidMove(Square)), SLOT(slotInvalidMove(Square)));
connect(ui.boardView, SIGNAL(wheelScrolled(int)), SLOT(slotChangePiece(int)));
connect(ui.boardView, SIGNAL(pieceDropped(Square, Piece)), SLOT(slotDroppedPiece(Square, Piece)));
connect(ui.toMoveButton, SIGNAL(clicked()), SLOT(slotToggleSide()));
connect(ui.wkCastleCheck, SIGNAL(stateChanged(int)), SLOT(slotCastlingRights()));
connect(ui.wqCastleCheck, SIGNAL(stateChanged(int)), SLOT(slotCastlingRights()));
connect(ui.bkCastleCheck, SIGNAL(stateChanged(int)), SLOT(slotCastlingRights()));
connect(ui.bqCastleCheck, SIGNAL(stateChanged(int)), SLOT(slotCastlingRights()));
connect(ui.epCombo, SIGNAL(currentIndexChanged(int)), SLOT(slotEnPassantSquare()));
connect(ui.halfmoveSpin, SIGNAL(valueChanged(int)), SLOT(slotHalfmoveClock()));
connect(ui.moveSpin, SIGNAL(valueChanged(int)), SLOT(slotMoveNumber()));
connect(ui.btFlipBoard, SIGNAL(clicked()), ui.boardView, SLOT(flip()));
ui.btFlipBoard->setCheckable(true);
connect(copyButton, SIGNAL(clicked()), SLOT(slotCopyFen()));
connect(pasteButton, SIGNAL(clicked()), SLOT(slotPasteFen()));
connect(btCopyText, SIGNAL(clicked()), SLOT(slotCopyText()));
connect(ui.btFlipVertical, SIGNAL(clicked()), SLOT(mirrorVertical()));
connect(ui.btFlipHorizontal, SIGNAL(clicked()), SLOT(mirrorHorizontal()));
connect(ui.btSwapColor, SIGNAL(clicked()), SLOT(swapColors()));
ui.tabWidget->setCurrentIndex(0);
}
void update() {
#ifdef INSTALL
if(cam.update()) {
ofPixels& pixels = cam.getColorPixels();
#else
cam.update();
if(cam.isFrameNew()) {
ofPixels& pixels = cam.getPixelsRef();
#endif
// next two could be replaced with one line
ofxCv::rotate90(pixels, rotated, rotate ? 270 : 0);
ofxCv:flip(rotated, rotated, 1);
Mat rotatedMat = toCv(rotated);
if(tracker.update(rotatedMat)) {
ofVec2f position = tracker.getPosition();
vector<FaceTrackerData*> neighbors = data.getNeighborsCount(position, neighborCount);
FaceTrackerData curData;
curData.load(tracker);
if(!neighbors.empty()) {
nearestData = *faceCompare.nearest(curData, neighbors);
if(nearestData.label != lastLabel) {
similar.loadImage(nearestData.getImageFilename());
#ifdef INSTALL
whitePoint = getWhitePoint(similar);
#else
whitePoint.set(1, 1, 1);
#endif
}
lastLabel = nearestData.label;
}
if(faceCompare.different(curData, currentData) && faceCompare.different(curData, neighbors)) {
saveFace(curData, rotated);
currentData.push_back(pair<ofVec2f, FaceTrackerData>(position, curData));
}
}
presence.update(tracker.getFound());
if(presence.wasTriggered()) {
presenceFade.stop();
}
if(presence.wasUntriggered()) {
for(int i = 0; i < currentData.size(); i++) {
data.add(currentData[i].first, currentData[i].second);
}
currentData.clear();
presenceFade.start();
}
}
}
void draw() {
ofBackground(255);
CGDisplayHideCursor(NULL);
ofSetColor(255);
if(similar.isAllocated()) {
shader.begin();
shader.setUniformTexture("tex", similar, 0);
shader.setUniform3fv("whitePoint", (float*) &whitePoint);
similar.draw(0, 0);
shader.end();
}
ofPushStyle();
if(presenceFade.getActive()) {
ofSetColor(0, ofMap(presenceFade.get(), 0, 1, 0, 128));
ofFill();
ofRect(0, 0, ofGetWidth(), ofGetHeight());
ofSetColor(255, ofMap(presenceFade.get(), 0, 1, 0, 32));
data.drawBins();
ofSetColor(255, ofMap(presenceFade.get(), 0, 1, 0, 64));
data.drawData();
}
ofSetColor(255, 64);
ofNoFill();
if(!tracker.getFound()) {
ofCircle(tracker.getPosition(), 10);
}
tracker.draw();
ofPopStyle();
#ifndef INSTALL
drawFramerate();
#endif
}
int start_ripping_gui(int ripping_flags)
{
char *albumdir, *musicfilename, *file_path = 0;
sacd_reader_t *sacd_reader;
scarletbook_handle_t *handle;
scarletbook_output_t *output;
msgType dialog_type;
int area_idx, i, ret;
uint32_t prev_upper_progress = 0;
uint32_t prev_lower_progress = 0;
uint32_t delta;
int prev_current_track = 0;
uint32_t prev_stats_total_sectors_processed = 0;
uint32_t prev_stats_current_file_sectors_processed = 0;
uint64_t tb_start, tb_freq;
uint64_t tmp_total_ripping_sectors = 0;
char progress_message[64];
sysAtomicSet(&stats_total_sectors, 0);
sysAtomicSet(&stats_total_sectors_processed, 0);
sysAtomicSet(&stats_current_file_total_sectors, 0);
sysAtomicSet(&stats_current_file_sectors_processed, 0);
sysAtomicSet(&stats_current_track, 0);
sysAtomicSet(&stats_total_tracks, 0);
sacd_reader = sacd_open("/dev_bdvd");
if (sacd_reader)
{
handle = scarletbook_open(sacd_reader, 0);
if (check_disc_space(sacd_reader, handle, ripping_flags))
{
ret = sacd_authenticate(sacd_reader);
if (ret != 0)
{
LOG(lm_main, LOG_ERROR, ("authentication failed: %x", ret));
}
// select the channel area
area_idx = ((has_multi_channel(handle) && ripping_flags & RIP_MCH) || !has_two_channel(handle)) ? handle->mulch_area_idx : handle->twoch_area_idx;
albumdir = get_album_dir(handle);
output = scarletbook_output_create(handle, handle_status_update_track_callback, handle_status_update_progress_callback, safe_fwprintf);
if (ripping_flags & RIP_ISO)
{
#define FAT32_SECTOR_LIMIT 2090000
uint32_t total_sectors = sacd_get_total_sectors(sacd_reader);
uint32_t sector_size = FAT32_SECTOR_LIMIT;
uint32_t sector_offset = 0;
if (total_sectors > FAT32_SECTOR_LIMIT)
{
musicfilename = (char *) malloc(512);
file_path = make_filename(output_device, 0, albumdir, "iso");
for (i = 1; total_sectors != 0; i++)
{
sector_size = min(total_sectors, FAT32_SECTOR_LIMIT);
snprintf(musicfilename, 512, "%s.%03d", file_path, i);
scarletbook_output_enqueue_raw_sectors(output, sector_offset, sector_size, musicfilename, "iso");
sector_offset += sector_size;
total_sectors -= sector_size;
}
free(file_path);
free(musicfilename);
}
else
{
file_path = make_filename(output_device, 0, albumdir, "iso");
scarletbook_output_enqueue_raw_sectors(output, 0, total_sectors, file_path, "iso");
free(file_path);
}
tmp_total_ripping_sectors = sacd_get_total_sectors(sacd_reader);
}
else
{
// do not overwrite previous dump
get_unique_dir(output_device, &albumdir);
// fill the queue with items to rip
for (i = 0; i < handle->area[area_idx].area_toc->track_count; i++)
{
musicfilename = get_music_filename(handle, area_idx, i, 0);
if (ripping_flags & RIP_DSF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dsf");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsf",
1 /* always decode to DSD */);
}
else if (ripping_flags & RIP_DSDIFF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dff");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsdiff",
((ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST) ? 0 : 1));
}
tmp_total_ripping_sectors += handle->area[area_idx].area_tracklist_offset->track_length_lsn[i];
free(musicfilename);
free(file_path);
}
file_path = make_filename(output_device, albumdir, 0, 0);
LOG(lm_main, LOG_NOTICE, ("setting output folder to: %s", file_path));
recursive_mkdir(file_path, 0777);
free(file_path);
}
scarletbook_output_start(output);
tb_freq = sysGetTimebaseFrequency();
tb_start = __gettime();
{
char *message = (char *) malloc(512);
file_path = make_filename(output_device, albumdir, 0, 0);
snprintf(message, 512, "Title: %s\nOutput: %s\nFormat: %s\nSize: %.2fGB\nArea: %s\nEncoding: %s",
substr(albumdir, 0, 100),
file_path,
(ripping_flags & RIP_DSDIFF ? "DSDIFF" : (ripping_flags & RIP_DSF ? "DSF" : "ISO")),
((double) ((tmp_total_ripping_sectors * SACD_LSN_SIZE) / 1073741824.00)),
(ripping_flags & RIP_2CH ? "2ch" : "mch"),
(ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST ? "DST" : (ripping_flags & RIP_ISO ? "DECRYPTED" : "DSD"))
);
free(file_path);
dialog_action = 0;
dialog_type = MSG_DIALOG_MUTE_ON | MSG_DIALOG_DOUBLE_PROGRESSBAR;
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
while (!user_requested_exit() && dialog_action == 0 && scarletbook_output_is_busy(output))
{
uint32_t tmp_stats_total_sectors_processed = sysAtomicRead(&stats_total_sectors_processed);
uint32_t tmp_stats_total_sectors = sysAtomicRead(&stats_total_sectors);
uint32_t tmp_stats_current_file_sectors_processed = sysAtomicRead(&stats_current_file_sectors_processed);
uint32_t tmp_stats_current_file_total_sectors = sysAtomicRead(&stats_current_file_total_sectors);
int tmp_current_track = sysAtomicRead(&stats_current_track);
if (tmp_current_track != 0 && tmp_current_track != prev_current_track)
{
memset(progress_message, 0, 64);
musicfilename = get_music_filename(handle, area_idx, tmp_current_track - 1, 0);
// HACK: substr is not thread safe, but it's only used in this thread..
snprintf(progress_message, 63, "Track (%d/%d): [%s...]", tmp_current_track, sysAtomicRead(&stats_total_tracks), substr(musicfilename, 0, 40));
free(musicfilename);
msgDialogProgressBarReset(MSG_PROGRESSBAR_INDEX0);
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX1, progress_message);
prev_upper_progress = 0;
prev_stats_current_file_sectors_processed = 0;
prev_current_track = tmp_current_track;
}
if (tmp_stats_total_sectors != 0 && prev_stats_total_sectors_processed != tmp_stats_total_sectors_processed)
{
delta = (tmp_stats_current_file_sectors_processed + (tmp_stats_current_file_sectors_processed - prev_stats_current_file_sectors_processed)) * 100 / tmp_stats_current_file_total_sectors - prev_upper_progress;
prev_upper_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX0, delta);
delta = (tmp_stats_total_sectors_processed + (tmp_stats_total_sectors_processed - prev_stats_total_sectors_processed)) * 100 / tmp_stats_total_sectors - prev_lower_progress;
prev_lower_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX1, delta);
snprintf(progress_message, 64, "Ripping %.1fMB/%.1fMB at %.2fMB/sec",
((float)(tmp_stats_current_file_sectors_processed * SACD_LSN_SIZE) / 1048576.00),
((float)(tmp_stats_current_file_total_sectors * SACD_LSN_SIZE) / 1048576.00),
(float)((float) tmp_stats_total_sectors_processed * SACD_LSN_SIZE / 1048576.00) / (float)((__gettime() - tb_start) / (float)(tb_freq)));
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX0, progress_message);
prev_stats_total_sectors_processed = tmp_stats_total_sectors_processed;
prev_stats_current_file_sectors_processed = tmp_stats_current_file_sectors_processed;
}
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
free(message);
}
free(albumdir);
scarletbook_output_destroy(output);
}
scarletbook_close(handle);
}
sacd_close(sacd_reader);
if (user_requested_exit())
{
return 0;
}
else if (1)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "ripping process completed.", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
}
return 0;
}
NoRSX::NoRSX(int real_screen_type, int buffer_screen_type) : EventHandler(){
screen_type = real_screen_type;
buffer_type = buffer_screen_type;
currentBuffer = 0;
host_addr = memalign(1024*1024, HOST_SIZE);
switch(real_screen_type){
case RESOLUTION_1920x1080: {
width=1920;height=1080;
buffers[0].width=1920;buffers[0].height=1080;
buffers[1].width=1920;buffers[1].height=1080;
} break;
case RESOLUTION_1280x720: {
width=1280;height=720;
buffers[0].width=1280;buffers[0].height=720;
buffers[1].width=1280;buffers[1].height=720;
} break;
case RESOLUTION_720x576: {
width=720;height=576;
buffers[0].width=720;buffers[0].height=576;
buffers[1].width=720;buffers[1].height=576;
} break;
case RESOLUTION_720x480: {
width=720;height=480;
buffers[0].width=720;buffers[0].height=480;
buffers[1].width=720;buffers[1].height=480;
} break;
default:
getResolution(&width,&height);
switch(real_screen_type){
default:
case RESOLUTION_AUTO_LOWER_1080p: {
if(height>=1080){
real_screen_type = RESOLUTION_1280x720;
width=1280;height=720;
buffers[0].width=1280;buffers[0].height=720;
buffers[1].width=1280;buffers[1].height=720;
}else
real_screen_type = RESOLUTION_AUTO;
} break;
case RESOLUTION_AUTO_LOWER_720p: {
if(height>=720){
real_screen_type = RESOLUTION_720x576;
width=720;height=576;
buffers[0].width=720;buffers[0].height=576;
buffers[1].width=720;buffers[1].height=576;
}else
real_screen_type = RESOLUTION_AUTO;
} break;
case RESOLUTION_AUTO_LOWER_576p: {
if(height>=576){
real_screen_type = RESOLUTION_720x480;
width=720;height=480;
buffers[0].width=720;buffers[0].height=480;
buffers[1].width=720;buffers[1].height=480;
}else
real_screen_type = RESOLUTION_AUTO;
} break;
real_screen_type = RESOLUTION_AUTO;
break;
}
break;
}
context = initScreen(host_addr, HOST_SIZE, real_screen_type, width, height);
for(int i=0;i<2;i++)
makeBuffer(&buffers[i],width,height,i);
switch(buffer_screen_type){
case RESOLUTION_1920x1080:
width=1920; height=1080;
break;
case RESOLUTION_1280x720:
width=1280; height=720;
break;
case RESOLUTION_720x576:
width=720; height=576;
break;
case RESOLUTION_720x480:
width=720; height=480;
break;
default:
getResolution(&width,&height);
break;
}
buffer = makeMemBuffer(width,height,&buffer_size);
buffer_size = buffers[0].width * buffers[0].height * sizeof(u32);
flip(context, 0);
setRenderTarget(context, &buffers[0]);
RegisterCallBack(EVENT_SLOT0);
}
void camera_feed()
{
VideoCapture cap(0);
if (cap.isOpened())
{
int distance[3], MUL = 1, dif = 0;
char key;
bool first_run = false, is_size_checked = false, moved = false, shoot = false;
unsigned long max_contours_amount = 0;
Point drawing_point, cursor, additional_point;
vector<vector<Point>> contours, main_points;
vector<Point> pen1, pen2, pens;
vector<Vec4i> hierarchy;
Mat frame, real_pic, drawing_frame, maze;
Scalar low_boundry(45, 107, 52), high_boundry(86, 227, 160), color(100, 100, 100);
//namedWindow("drawing_frame", 1);
//namedWindow("frame", 1);
cap >> frame;
cursor = Point(20, 20);
maze = imread("maze1.jpg");
maze = maze / WHITE;
maze = maze * WHITE;
bitwise_not(maze, maze);
RECT rect = { 0 }; // gaming stuff!
HWND window = FindWindow("Chicken Invaders 5", "Chicken Invaders 5");
Sleep(2000);
if (window)
{
GetClientRect(window, &rect);
SetForegroundWindow(window);
SetActiveWindow(window);
SetFocus(window);
}
while (true)
{
shoot = false;
cap >> frame;
real_pic = frame.clone();
while (main_points.size() != 0)
{
main_points.pop_back();
}
if (!first_run)
{
drawing_frame = real_pic.clone();
resize(drawing_frame, drawing_frame, Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) - 50));
resize(maze, maze, Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) - 50));
first_run = true;
}
flip(real_pic, real_pic, 1);
cvtColor(frame, frame, COLOR_BGR2HSV);
inRange(frame, low_boundry, high_boundry, frame);
flip(frame, frame, 1);
contours.clear();
resize(frame, frame, Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)));
findContours(frame, contours, hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
is_size_checked = false;
if (contours.size() != 0)
{
for (vector<vector<Point>>::iterator it = contours.begin(); it != contours.end(); it++)
{
if (it->size() > max_contours_amount * 0.7)
{
main_points.push_back(*it);
max_contours_amount = it->size();
is_size_checked = true;
}
}
}
if (is_size_checked)
{
moved = false;
drawing_point = stabilized_point(main_points[0]);
if (main_points.size() == 2)
{
if (stabilized_point(main_points[0]).x < stabilized_point(main_points[1]).x)
{
drawing_point = stabilized_point(main_points[1]);
}
shoot = true;
}
drawing_point.x += (drawing_point.x - drawing_frame.size().width / 2) / 10;
drawing_point.y += (drawing_point.y - drawing_frame.size().height / 2) / 10;
while (drawing_point.x > maze.size().width)
{
drawing_point.x--;
}
while (drawing_point.x < 0)
{
drawing_point.x++;
}
while (drawing_point.y > maze.size().height)
{
drawing_point.y--;
}
while (drawing_point.y < 0)
{
drawing_point.y++;
}
distance[0] = drawing_point.x - cursor.x;
distance[1] = drawing_point.y - cursor.y;
while (distance[0] != 0 && distance[1] != 0)
{
if (maze.at<Vec3b>(Point(cursor.x + distance[0] / 15, cursor.y))[0] != WHITE)
{
cursor.x += distance[0] / 15;
distance[0] /= 15;
moved = true;
}
if (maze.at<Vec3b>(Point(cursor.x, cursor.y + distance[1] / 15))[0] != WHITE)
{
cursor.y += distance[1] / 15;
distance[1] /= 15;
moved = true;
}
if (!moved)
{
putText(drawing_frame, "Struck a wall!", Point(0, 40), FONT_HERSHEY_COMPLEX_SMALL, 1, Scalar(WHITE, WHITE, BLACK, 1), 1, CV_AA);
distance[0] = 0;
distance[1] = 0;
}
}
SetCursorPos(drawing_point.x, drawing_point.y); // gaming stuff!
circle(drawing_frame, cursor, 13, Scalar(WHITE, BLACK, WHITE), 2);
circle(drawing_frame, drawing_point, 13, Scalar(WHITE, BLACK, WHITE), -1);
//circle(drawing_frame, stabilized_point(pen1), 13, Scalar(WHITE, WHITE, BLACK), -1);
}
else
{
putText(drawing_frame, "Lost drawing object!", Point(0, 20), FONT_HERSHEY_COMPLEX_SMALL, 1, Scalar(WHITE, WHITE, BLACK, 1), 1, CV_AA);
circle(drawing_frame, cursor, 13, Scalar(WHITE, WHITE, BLACK), 3);
}
if (shoot)
{
LeftClick(drawing_point.x, drawing_point.y);
}
key = waitKey(10);
drawing_frame = maze + drawing_frame;
bitwise_not(drawing_frame, drawing_frame);
//imshow("drawing_frame", drawing_frame);
//imshow("frame", frame);
frame = BLACK;
drawing_frame = BLACK;
real_pic = BLACK;
}
}
int main (int argc, char ** argv) {
yctx = yutani_init();
win_width = 100;
win_height = 100;
init_decorations();
off_x = decor_left_width;
off_y = decor_top_height;
/* Do something with a window */
wina = yutani_window_create(yctx, win_width + decor_width(), win_height + decor_height());
yutani_window_move(yctx, wina, 300, 300);
ctx = init_graphics_yutani_double_buffer(wina);
draw_fill(ctx, rgb(0,0,0));
redraw_borders();
flip(ctx);
yutani_flip(yctx, wina);
yutani_window_advertise(yctx, wina, "Graphics Test");
pthread_t thread;
pthread_create(&thread, NULL, draw_thread, NULL);
while (!should_exit) {
yutani_msg_t * m = yutani_poll(yctx);
if (m) {
switch (m->type) {
case YUTANI_MSG_KEY_EVENT:
{
struct yutani_msg_key_event * ke = (void*)m->data;
if (ke->event.action == KEY_ACTION_DOWN && ke->event.keycode == 'q') {
should_exit = 1;
}
}
break;
case YUTANI_MSG_WINDOW_FOCUS_CHANGE:
{
struct yutani_msg_window_focus_change * wf = (void*)m->data;
yutani_window_t * win = hashmap_get(yctx->windows, (void*)wf->wid);
if (win) {
win->focused = wf->focused;
}
}
break;
case YUTANI_MSG_SESSION_END:
should_exit = 1;
break;
case YUTANI_MSG_RESIZE_OFFER:
{
struct yutani_msg_window_resize * wr = (void*)m->data;
spin_lock(&draw_lock);
resize_finish(wr->width, wr->height);
spin_unlock(&draw_lock);
}
break;
case YUTANI_MSG_WINDOW_MOUSE_EVENT:
if (decor_handle_event(yctx, m) == DECOR_CLOSE) {
should_exit = 1;
}
break;
default:
break;
}
free(m);
}
}
yutani_close(yctx, wina);
return 0;
}
NxU16 readWord(bool mismatch, const NxStream& stream)
{
NxU16 d = stream.readWord();
if(mismatch) d = flip(&d);
return d;
}
void CglGMI::generateCuts(OsiCuts &cs)
{
isInteger = new bool[ncol];
computeIsInteger();
cstat = new int[ncol];
rstat = new int[nrow];
solver->getBasisStatus(cstat, rstat); // 0: free 1: basic
// 2: upper 3: lower
#if defined GMI_TRACETAB
printvecINT("cstat", cstat, ncol);
printvecINT("rstat", rstat, nrow);
#endif
// list of basic integer fractional variables
int *listFracBasic = new int[nrow];
int numFracBasic = 0;
for (int i = 0; i < ncol; ++i) {
// j is the variable which is basic in row i
if ((cstat[i] == 1) && (isInteger[i])) {
if (CoinMin(aboveInteger(xlp[i]),
1-aboveInteger(xlp[i])) > param.getAway()) {
listFracBasic[numFracBasic] = i;
numFracBasic++;
}
#if defined TRACK_REJECT || defined TRACK_REJECT_SIMPLE
else if (trackRejection) {
// Say that we tried to generate a cut, but it was discarded
// because of small fractionality
if (!isIntegerValue(xlp[i])) {
fracFail++;
numGeneratedCuts++;
}
}
#endif
}
}
#if defined GMI_TRACE
printf("CglGMI::generateCuts() : %d fractional rows\n", numFracBasic);
#endif
if (numFracBasic == 0) {
delete[] listFracBasic;
delete[] cstat;
delete[] rstat;
delete[] isInteger;
return;
}
// there are rows with basic integer fractional variables, so we can
// generate cuts
// Basis index for columns and rows; each element is -1 if corresponding
// variable is nonbasic, and contains the basis index if basic.
// The basis index is the row in which the variable is basic.
int* colBasisIndex = new int[ncol];
int* rowBasisIndex = new int[nrow];
#if defined OSI_TABLEAU
memset(colBasisIndex, -1, ncol*sizeof(int));
memset(rowBasisIndex, -1, nrow*sizeof(int));
solver->enableFactorization();
int* basicVars = new int[nrow];
solver->getBasics(basicVars);
for (int i = 0; i < nrow; ++i) {
if (basicVars[i] < ncol) {
colBasisIndex[basicVars[i]] = i;
}
else {
rowBasisIndex[basicVars[i] - ncol] = i;
}
}
#else
CoinFactorization factorization;
if (factorize(factorization, colBasisIndex, rowBasisIndex)) {
printf("### WARNING: CglGMI::generateCuts(): error during factorization!\n");
return;
}
#endif
// cut in sparse form
double* cutElem = new double[ncol];
int* cutIndex = new int[ncol];
int cutNz = 0;
double cutRhs;
// cut in dense form
double* cut = new double[ncol];
double *slackVal = new double[nrow];
for (int i = 0; i < nrow; ++i) {
slackVal[i] = rowRhs[i] - rowActivity[i];
}
#if defined OSI_TABLEAU
// Column part and row part of a row of the simplex tableau
double* tableauColPart = new double[ncol];
double* tableauRowPart = new double[nrow];
#else
// Need some more data for simplex tableau computation
const int * row = byCol->getIndices();
const CoinBigIndex * columnStart = byCol->getVectorStarts();
const int * columnLength = byCol->getVectorLengths();
const double * columnElements = byCol->getElements();
// Create work arrays for factorization
// two vectors for updating: the first one is needed to do the computations
// but we do not use it, the second one contains a row of the basis inverse
CoinIndexedVector work;
CoinIndexedVector array;
// Make sure they large enough
work.reserve(nrow);
array.reserve(nrow);
int * arrayRows = array.getIndices();
double * arrayElements = array.denseVector();
// End of code to create work arrays
double one = 1.0;
#endif
// Matrix elements by row for slack substitution
const double *elements = byRow->getElements();
const int *rowStart = byRow->getVectorStarts();
const int *indices = byRow->getIndices();
const int *rowLength = byRow->getVectorLengths();
// Indices of basic and slack variables, and cut elements
int iBasic, slackIndex;
double cutCoeff;
double rowElem;
// Now generate the cuts: obtain a row of the simplex tableau
// where an integer variable is basic and fractional, and compute the cut
for (int i = 0; i < numFracBasic; ++i) {
if (!computeCutFractionality(xlp[listFracBasic[i]], cutRhs)) {
// cut is discarded because of the small fractionalities involved
#if defined TRACK_REJECT || defined TRACK_REJECT_SIMPLE
if (trackRejection) {
// Say that we tried to generate a cut, but it was discarded
// because of small fractionality
fracFail++;
numGeneratedCuts++;
}
#endif
continue;
}
// the variable listFracBasic[i] is basic in row iBasic
iBasic = colBasisIndex[listFracBasic[i]];
#if defined GMI_TRACE
printf("Row %d with var %d basic, f0 = %f\n", i, listFracBasic[i], f0);
#endif
#if defined OSI_TABLEAU
solver->getBInvARow(iBasic, tableauColPart, tableauRowPart);
#else
array.clear();
array.setVector(1, &iBasic, &one);
factorization.updateColumnTranspose (&work, &array);
int numberInArray=array.getNumElements();
#endif
// reset the cut
memset(cut, 0, ncol*sizeof(double));
// columns
for (int j = 0; j < ncol; ++j) {
if ((colBasisIndex[j] >= 0) ||
(areEqual(colLower[j], colUpper[j],
param.getEPS(), param.getEPS()))) {
// Basic or fixed variable -- skip
continue;
}
#ifdef OSI_TABLEAU
rowElem = tableauColPart[j];
#else
rowElem = 0.0;
// add in row of tableau
for (int h = columnStart[j]; h < columnStart[j]+columnLength[j]; ++h) {
rowElem += columnElements[h]*arrayElements[row[h]];
}
#endif
if (!isZero(fabs(rowElem))) {
// compute cut coefficient
flip(rowElem, j);
cutCoeff = computeCutCoefficient(rowElem, j);
if (isZero(cutCoeff)) {
continue;
}
unflipOrig(cutCoeff, j, cutRhs);
cut[j] = cutCoeff;
#if defined GMI_TRACE
printf("var %d, row %f, cut %f\n", j, rowElem, cutCoeff);
#endif
}
}
// now do slacks part
#if defined OSI_TABLEAU
for (int j = 0 ; j < nrow; ++j) {
// index of the row corresponding to the slack variable
slackIndex = j;
if (rowBasisIndex[j] >= 0) {
// Basic variable -- skip it
continue;
}
rowElem = tableauRowPart[j];
#else
for (int j = 0 ; j < numberInArray ; ++j) {
// index of the row corresponding to the slack variable
slackIndex = arrayRows[j];
rowElem = arrayElements[slackIndex];
#endif
if (!isZero(fabs(rowElem))) {
slackIndex += ncol;
// compute cut coefficient
flip(rowElem, slackIndex);
cutCoeff = computeCutCoefficient(rowElem, slackIndex);
if (isZero(fabs(cutCoeff))) {
continue;
}
unflipSlack(cutCoeff, slackIndex, cutRhs, slackVal);
eliminateSlack(cutCoeff, slackIndex, cut, cutRhs,
elements, rowStart, indices, rowLength, rowRhs);
#if defined GMI_TRACE
printf("var %d, row %f, cut %f\n", slackIndex, rowElem, cutCoeff);
#endif
}
}
packRow(cut, cutElem, cutIndex, cutNz);
if (cutNz == 0)
continue;
#if defined GMI_TRACE
printvecDBL("final cut:", cutElem, cutIndex, cutNz);
printf("cutRhs: %f\n", cutRhs);
#endif
#if defined TRACK_REJECT || defined TRACK_REJECT_SIMPLE
if (trackRejection) {
numGeneratedCuts++;
}
#endif
if (cleanCut(cutElem, cutIndex, cutNz, cutRhs, xlp) && cutNz > 0) {
OsiRowCut rc;
rc.setRow(cutNz, cutIndex, cutElem);
rc.setLb(-param.getINFINIT());
rc.setUb(cutRhs);
if (!param.getCHECK_DUPLICATES()) {
cs.insert(rc);
}
else{
cs.insertIfNotDuplicate(rc, CoinAbsFltEq(param.getEPS_COEFF()));
}
}
}
#if defined GMI_TRACE
printf("CglGMI::generateCuts() : number of cuts : %d\n", cs.sizeRowCuts());
#endif
#if defined OSI_TABLEAU
solver->disableFactorization();
delete[] basicVars;
delete[] tableauColPart;
delete[] tableauRowPart;
#endif
delete[] colBasisIndex;
delete[] rowBasisIndex;
delete[] cut;
delete[] slackVal;
delete[] cutElem;
delete[] cutIndex;
delete[] listFracBasic;
delete[] cstat;
delete[] rstat;
delete[] isInteger;
} /* generateCuts */
/***********************************************************************/
void CglGMI::setParam(const CglGMIParam &source) {
param = source;
} /* setParam */
/***********************************************************************/
void CglGMI::computeIsInteger() {
for (int i = 0; i < ncol; ++i) {
if(solver->isInteger(i)) {
isInteger[i] = true;
}
else {
if((areEqual(colLower[i], colUpper[i],
param.getEPS(), param.getEPS()))
&& (isIntegerValue(colUpper[i]))) {
// continuous variable fixed to an integer value
isInteger[i] = true;
}
else {
isInteger[i] = false;
}
}
}
} /* computeIsInteger */
/***********************************************************************/
void CglGMI::printOptTab(OsiSolverInterface *lclSolver) const
{
int *cstat = new int[ncol];
int *rstat = new int[nrow];
lclSolver->enableFactorization();
lclSolver->getBasisStatus(cstat, rstat); // 0: free 1: basic
// 2: upper 3: lower
int *basisIndex = new int[nrow]; // basisIndex[i] =
// index of pivot var in row i
// (slack if number >= ncol)
lclSolver->getBasics(basisIndex);
double *z = new double[ncol]; // workspace to get row of the tableau
double *slack = new double[nrow]; // workspace to get row of the tableau
double *slackVal = new double[nrow];
for (int i = 0; i < nrow; i++) {
slackVal[i] = rowRhs[i] - rowActivity[i];
}
const double *rc = lclSolver->getReducedCost();
const double *dual = lclSolver->getRowPrice();
const double *solution = lclSolver->getColSolution();
printvecINT("cstat", cstat, ncol);
printvecINT("rstat", rstat, nrow);
printvecINT("basisIndex", basisIndex, nrow);
printvecDBL("solution", solution, ncol);
printvecDBL("slackVal", slackVal, nrow);
printvecDBL("reduced_costs", rc, ncol);
printvecDBL("dual solution", dual, nrow);
printf("Optimal Tableau:\n");
for (int i = 0; i < nrow; i++) {
lclSolver->getBInvARow(i, z, slack);
for (int ii = 0; ii < ncol; ++ii) {
printf("%5.2f ", z[ii]);
}
printf(" | ");
for (int ii = 0; ii < nrow; ++ii) {
printf("%5.2f ", slack[ii]);
}
printf(" | ");
if(basisIndex[i] < ncol) {
printf("%5.2f ", solution[basisIndex[i]]);
}
else {
printf("%5.2f ", slackVal[basisIndex[i]-ncol]);
}
printf("\n");
}
for (int ii = 0; ii < 7*(ncol+nrow+1); ++ii) {
printf("-");
}
printf("\n");
for (int ii = 0; ii < ncol; ++ii) {
printf("%5.2f ", rc[ii]);
}
printf(" | ");
for (int ii = 0; ii < nrow; ++ii) {
printf("%5.2f ", -dual[ii]);
}
printf(" | ");
printf("%5.2f\n", -lclSolver->getObjValue());
lclSolver->disableFactorization();
delete[] cstat;
delete[] rstat;
delete[] basisIndex;
delete[] slack;
delete[] z;
delete[] slackVal;
} /* printOptTab */
NxF32 readFloat(bool mismatch, const NxStream& stream)
{
NxU32 d = stream.readDword();
if(mismatch) d = flip(&d);
return FR(d);
}
/// Post constraint on \a x
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::exp(home, x[0], x[1]);
else
Gecode::rel(home, exp(x[0]) == x[1]);
}
void writeFloat(NxF32 value, bool mismatch, NxStream& stream)
{
if(mismatch) value = flip(&value);
stream.storeFloat(value);
}
float cv::intersectConvexConvex( InputArray _p1, InputArray _p2, OutputArray _p12, bool handleNested )
{
Mat p1 = _p1.getMat(), p2 = _p2.getMat();
CV_Assert( p1.depth() == CV_32S || p1.depth() == CV_32F );
CV_Assert( p2.depth() == CV_32S || p2.depth() == CV_32F );
int n = p1.checkVector(2, p1.depth(), true);
int m = p2.checkVector(2, p2.depth(), true);
CV_Assert( n >= 0 && m >= 0 );
if( n < 2 || m < 2 )
{
_p12.release();
return 0.f;
}
AutoBuffer<Point2f> _result(n*2 + m*2 + 1);
Point2f *fp1 = _result, *fp2 = fp1 + n;
Point2f* result = fp2 + m;
int orientation = 0;
for( int k = 1; k <= 2; k++ )
{
Mat& p = k == 1 ? p1 : p2;
int len = k == 1 ? n : m;
Point2f* dst = k == 1 ? fp1 : fp2;
Mat temp(p.size(), CV_MAKETYPE(CV_32F, p.channels()), dst);
p.convertTo(temp, CV_32F);
CV_Assert( temp.ptr<Point2f>() == dst );
Point2f diff0 = dst[0] - dst[len-1];
for( int i = 1; i < len; i++ )
{
double s = diff0.cross(dst[i] - dst[i-1]);
if( s != 0 )
{
if( s < 0 )
{
orientation++;
flip( temp, temp, temp.rows > 1 ? 0 : 1 );
}
break;
}
}
}
float area = 0.f;
int nr = intersectConvexConvex_(fp1, n, fp2, m, result, &area);
if( nr == 0 )
{
if( !handleNested )
{
_p12.release();
return 0.f;
}
if( pointPolygonTest(_InputArray(fp1, n), fp2[0], false) >= 0 )
{
result = fp2;
nr = m;
}
else if( pointPolygonTest(_InputArray(fp2, n), fp1[0], false) >= 0 )
{
result = fp1;
nr = n;
}
else
{
_p12.release();
return 0.f;
}
area = (float)contourArea(_InputArray(result, nr), false);
}
if( _p12.needed() )
{
Mat temp(nr, 1, CV_32FC2, result);
// if both input contours were reflected,
// let's orient the result as the input vectors
if( orientation == 2 )
flip(temp, temp, 0);
temp.copyTo(_p12);
}
return (float)fabs(area);
}
int main(int argc, const char *argv[])
{
ALLEGRO_EVENT event;
ALLEGRO_KEYBOARD_STATE kst;
bool blend;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
display = al_create_display(W, H);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
black = al_map_rgb_f(0.0, 0.0, 0.0);
white = al_map_rgb_f(1.0, 1.0, 1.0);
background = al_map_rgb_f(0.5, 0.5, 0.6);
if (argc > 1 && 0 == strcmp(argv[1], "--memory-bitmap")) {
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
}
dbuf = al_create_bitmap(W, H);
if (!dbuf) {
abort_example("Error creating double buffer\n");
return 1;
}
al_set_target_bitmap(dbuf);
al_clear_to_color(background);
draw_clip_rect();
flip();
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
while (true) {
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
al_get_keyboard_state(&kst);
blend = al_key_down(&kst, ALLEGRO_KEY_LSHIFT) ||
al_key_down(&kst, ALLEGRO_KEY_RSHIFT);
if (event.mouse.button == 1) {
plonk(event.mouse.x, event.mouse.y, blend);
} else {
splat(event.mouse.x, event.mouse.y, blend);
}
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_OUT) {
last_x = last_y = -1;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN &&
event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
{
break;
}
}
al_destroy_event_queue(queue);
al_destroy_bitmap(dbuf);
return 0;
}
int main(int argc, char* argv[])
{
srand (time(0));
if(argc < 4)
{
cerr << "ERROR: The number of arguments is incorrect" << endl << "Enter:\targ_1 = user_definition_file\t arg_2 = genetic_encoding_file\t arg_3 = port_number";
return -1;
}
if(system((char*)"mkdir -p NEAT_organisms") == -1)
{
cerr << "TRAIN ERROR:\tFailed to create folder 'NEAT_organisms'" << endl;
}
if(system("rm -f NEAT_organisms/*") == -1)
{
cerr << "TRAIN ERROR:\tFailed to remove files inside of 'NEAT_organisms'" << endl;
}
SimFiles * simfile = new SimFiles();
Fitness * fitness = new Fitness();
RobotVREP * vrep = new RobotVREP(false, atoi(argv[3]));
// ============= VREP INITIALIZATIONS ============= //
Joint * rightWheel = new Joint((char*)"SCALE", (char*)"motor_der");
Joint * leftWheel = new Joint((char*)"SCALE", (char*)"motor_izq");
vrep->addJoint(rightWheel);
vrep->addJoint(leftWheel);
VisionSensor * visionSensor = new VisionSensor((char*)"VisionSensor");
vrep->addVisionSensor(visionSensor);
Object * centerDummy = new Object((char*)"modi_dummy");
Object * Modi = new Object((char*)"MODI");
vrep->addObject(centerDummy);
vrep->addObject(Modi);
CollisionObject * chasis = new CollisionObject((char*)"Collision_MODI_1#");
CollisionObject * rueda1 = new CollisionObject((char*)"Collision_MODI_2#");
CollisionObject * rueda2 = new CollisionObject((char*)"Collision_MODI_3#");
vrep->addCollisionObject(chasis);
vrep->addCollisionObject(rueda1);
vrep->addCollisionObject(rueda2);
vector < CollisionObject * > structure = {chasis, rueda1, rueda2};
vector < Object * > cubes;
// Set random position of Obstacles
double y0 = -2;
for(int cp_y = 0; cp_y < 9; cp_y++)
{
double x0 = -2 + 0.25*(cp_y%2);
for(int cp_x = 0; cp_x < 8 + (cp_y + 1)%2; cp_x++)
{
if(9*cp_y + cp_x != 40)
{
stringstream sstm1;
sstm1 << "Obstacle" << 9*cp_y+cp_x<< "#";
Object * obstacle = new Object((char*)sstm1.str().c_str());
vrep->addObject(obstacle);
double rand1 = rand()%201 - 100;
double rand2 = rand()%201 - 100;
vector < double > position;
position.push_back(x0 + rand1/100*.10);
position.push_back(y0 + rand2/100*.10);
position.push_back(0.05);
vrep->setObjectPosition(obstacle, position);
cubes.push_back(obstacle);
}
x0 = x0 + 0.5;
}
y0 = y0 + 0.5;
}
// ================================================ //
// ========== NEAT INITIALIZATIONS =========== //
vector < double > output(2,0.0);
vector < double > input(NX*NY+2,0.0);
Population population(argv[1], argv[2], (char *)"NEAT_RIAR", (char *)"./NEAT_organisms");
// ================================================ //
namedWindow( "Display window", WINDOW_AUTOSIZE ); // Create a window for display.
int finalChampionGeneration = 0;
int finalChampionPopulation = 0;
double finalChampionFitness = 0.0;
for(int g = 0; g < population.GENERATIONS; g++)
{
fitness->resetGenerationValues();
int generationChampionPopulation = 0;
double generationChampionFitness = 0.0;
for(int p = 0; p < population.POPULATION_MAX; p++)
{
fitness->resetPopulationValues();
int sim_time = 0;
bool flag = true;
int flag_times = 0;
double rightVel = 0.0;
double leftVel = 0.0;
vrep->setJointTargetVelocity(rightWheel, 0.0);
vrep->setJointTargetVelocity(leftWheel, 0.0);
double rand1 = rand()%201 - 100;
double rand2 = rand()%201 - 100;
double rand3 = rand()%201 - 100;
vector < double > position, orientation;
position.push_back(rand1/100*.10);
position.push_back(rand2/100*.10);
position.push_back(0.03011);
orientation.push_back(0);
orientation.push_back(0);
orientation.push_back(rand3/100*M_PI);
vrep->setObjectPosition(Modi, position);
vrep->setObjectOrientation(Modi, orientation);
unsigned char * image;
Mat frameRGB = Mat(NX, NY, CV_8UC3);
Mat frameGRAY = Mat(NX, NY, CV_8UC1);
stringstream message1, message2, video_name;
message1 << "Generation " << g << " Population " << p;
vrep->addStatusbarMessage((char*)message1.str().c_str());
video_name << "G" << g << "P" << p;
//vrep->changeVideoName((char *)video_name.str().c_str(), simx_opmode_oneshot_wait);
simfile->openRobotMovementFile(g, p);
simfile->openRobotMotorVelocityFile(g, p);
clog << "======= G" << g << " P" << p << " ======= " << endl;
vrep->startSimulation(simx_opmode_oneshot_wait);
timeval tv1, tv2;
gettimeofday(&tv1, NULL);
while(sim_time < TIME_SIMULATION && flag)
{
image = vrep->getVisionSensorImage(visionSensor);
frameRGB.data = image;
flip(frameRGB, frameRGB, 0);
cvtColor(frameRGB,frameGRAY,CV_BGR2GRAY);
Mat tmp = frameGRAY;
Mat frame = tmp;
resize(tmp, frame, Size(0,0) , 6.0, 6.0, (int)INTER_NEAREST );
imshow( "Display window", frame );
waitKey(10);
for(int i = 0; i < NY; i++)
{
for(int j = 0;j < NX; j++)
{
input.at(i*NX + j) = (double)frame.at<uchar>(i,j)/255*2-1;
}
}
input.at(NX*NY) = (double)((2.0/(MAX_VEL - MIN_VEL))*(rightVel - MIN_VEL) - 1.0);
input.at(NX*NY + 1) = (double)((2.0/(MAX_VEL - MIN_VEL))*(leftVel - MIN_VEL) - 1.0);
output = population.organisms.at(p).eval(input);
rightVel = output.at(0) + rightVel;
leftVel = output.at(1) + leftVel;
if(rightVel > MAX_VEL) rightVel = MAX_VEL;
else if(rightVel < MIN_VEL) rightVel = MIN_VEL;
if(leftVel > MAX_VEL) leftVel = MAX_VEL;
else if(leftVel < MIN_VEL) leftVel = MIN_VEL;
vrep->setJointTargetVelocity(rightWheel,-rightVel);
vrep->setJointTargetVelocity(leftWheel,leftVel);
if(sim_time > TIME_INIT_MEASURING)
{
position = vrep->getObjectPosition(centerDummy);
orientation = vrep->getObjectOrientation(centerDummy);
simfile->addRobotMovementFile((double)sim_time/1000000.0, position, orientation.at(2));
simfile->addRobotMotorVelocityFile((double)sim_time/1000000.0, rightVel, leftVel);
fitness->measuringValues(position, rightVel, leftVel, vrep->readCollision(structure));
if (abs(orientation.at(0)) > 0.78 || abs(orientation.at(1)) > 0.78)
{
flag_times++;
if(flag_times > 10) flag = false;
}else
flag_times = 0;
}
usleep(DELTA_TIME - EXECUTION_TIME);
sim_time += DELTA_TIME;
}
vrep->stopSimulation(simx_opmode_oneshot_wait);
gettimeofday(&tv2, NULL);
long int simulationtime = ((tv2.tv_sec - tv1.tv_sec)*1000000L + tv2.tv_usec) - tv1.tv_usec;
simfile->closeRobotMovementFile();
simfile->closeRobotMotorVelocityFile();
if (flag)
{
population.organisms.at(p).fitness = fitness->calculateFitness();
simfile->addFileResults(fitness->getFitness(), g, p);
clog << "Fitness:\t" << fitness->getFitness() << endl;
clog << "Distance:\t" << fitness->getDistance() << endl;
clog << "Tiempo de simulación:\t" << (double)simulationtime/1000000 << endl;
clog << endl;
message2 << "FITNESS : " << fitness->getFitness();
vrep->addStatusbarMessage((char*)message2.str().c_str());
if(generationChampionFitness < fitness->getFitness())
{
generationChampionPopulation = p;
generationChampionFitness = fitness->getFitness();
}
}
else
{
clog << "OVERTURNING! The simulation has stopped" << endl;
population.organisms.at(p).fitness = FAILED_FITNESS;
}
}
simfile->addFileChampion(generationChampionFitness, g, generationChampionPopulation);
simfile->addFileFitness(fitness->getGenerationFitness(), g);
//////////////////////////// SAVE CHAMPION FILES /////////////////////////////////
stringstream generation_champion_filename;
generation_champion_filename << "NEAT_organisms/Champion_G" << g << "P" << generationChampionPopulation << ".txt";
population.organisms.at(generationChampionPopulation).save((char *)generation_champion_filename.str().c_str());
stringstream cp_gen_champion_movement, cp_gen_champion_motorVelocity;
cp_gen_champion_movement << "cp simulation_files/movement/movement_G" << g << "P" << generationChampionPopulation << ".txt ./simulation_files/movement/Champion_G" << g << "P" << generationChampionPopulation << ".txt";
cp_gen_champion_motorVelocity << "cp simulation_files/motorVelocity/motorVelocity_G" << g << "P" << generationChampionPopulation << ".txt ./simulation_files/motorVelocity/Champion_G" << g << "P" << generationChampionPopulation << ".txt";
if(system((char*)cp_gen_champion_movement.str().c_str()) == -1)
{
cerr << "TRAIN ERROR:\tFailed to copy the Champion movement File" << endl;
}
else
{
if(system("rm -f ./simulation_files/movement/movement_G*.txt") == -1)
{
cerr << "TRAIN ERROR:\tFailed to remove useless files" << endl;
}
}
if(system((char*)cp_gen_champion_motorVelocity.str().c_str()) == -1)
{
cerr << "TRAIN ERROR:\tFailed to copy the Champion motor velocity File" << endl;
}
else
{
if(system("rm -f ./simulation_files/motorVelocity/motorVelocity_G*.txt") == -1)
{
cerr << "TRAIN ERROR:\tFailed to remove useless files" << endl;
}
}
///////////////////////////////////////////////////////////////////////////////////
population.epoch();
if(finalChampionFitness < generationChampionFitness)
{
finalChampionGeneration = g;
finalChampionPopulation = generationChampionPopulation;
finalChampionFitness = generationChampionFitness;
}
}
//////////////////////////// SAVE CHAMPION FILES /////////////////////////////////
stringstream cp_champion_organism, cp_champion_movement, cp_champion_motorVelocity;
cp_champion_organism << "cp NEAT_organisms/Champion_G" << finalChampionGeneration << "P" << finalChampionPopulation << ".txt ./NEAT_organisms/Champion.txt";
cp_champion_movement << "cp simulation_files/movement/Champion_G" << finalChampionGeneration << "P" << finalChampionPopulation << ".txt ./simulation_files/movement/Champion.txt";
cp_champion_motorVelocity << "cp simulation_files/motorVelocity/Champion_G" << finalChampionGeneration << "P" << finalChampionPopulation << ".txt ./simulation_files/motorVelocity/Champion.txt";
if(system((char*)cp_champion_organism.str().c_str()) == -1)
{
cerr << "TRAIN ERROR:\tFailed to copy the Champion Organism File" << endl;
}
if(system((char*)cp_champion_movement.str().c_str()) == -1)
{
cerr << "TRAIN ERROR:\tFailed to copy the Champion Movement File" << endl;
}
if(system((char*)cp_champion_motorVelocity.str().c_str()) == -1)
{
cerr << "TRAIN ERROR:\tFailed to copy the Champion Motor Velocity File" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
clog << "Fitness champion: " << finalChampionFitness << "\n\n"<< endl;
delete(vrep);
delete(simfile);
delete(fitness);
return(0);
}
static void
init_screen(glw_ps3_t *gp)
{
// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
void *host_addr = memalign(1024*1024, 1024*1024);
assert(host_addr != NULL);
// Initilise Reality, which sets up the command buffer and shared IO memory
gp->gr.gr_be.be_ctx = realityInit(0x10000, 1024*1024, host_addr);
assert(gp->gr.gr_be.be_ctx != NULL);
gcmConfiguration config;
gcmGetConfiguration(&config);
TRACE(TRACE_INFO, "RSX", "memory @ 0x%x size = %d\n",
config.localAddress, config.localSize);
hts_mutex_init(&gp->gr.gr_be.be_mempool_lock);
gp->gr.gr_be.be_mempool = extent_create(0, config.localSize >> 4);
gp->gr.gr_be.be_rsx_address = (void *)(uint64_t)config.localAddress;
VideoState state;
videoGetState(0, 0, &state);
// Get the current resolution
videoGetResolution(state.displayMode.resolution, &gp->res);
int num = gp->res.width;
int den = gp->res.height;
switch(state.displayMode.aspect) {
case VIDEO_ASPECT_4_3:
num = 4; den = 3;
break;
case VIDEO_ASPECT_16_9:
num = 16; den = 9;
break;
}
gp->scale = (float)(num * gp->res.height) / (float)(den * gp->res.width);
TRACE(TRACE_INFO, "RSX",
"Video resolution %d x %d aspect=%d, pixel wscale=%f",
gp->res.width, gp->res.height, state.displayMode.aspect, gp->scale);
gp->framebuffer_pitch = 4 * gp->res.width; // each pixel is 4 bytes
gp->depthbuffer_pitch = 4 * gp->res.width; // And each value in the depth buffer is a 16 bit float
// Configure the buffer format to xRGB
VideoConfiguration vconfig;
memset(&vconfig, 0, sizeof(VideoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = gp->framebuffer_pitch;
videoConfigure(0, &vconfig, NULL, 0);
videoGetState(0, 0, &state);
const s32 buffer_size = gp->framebuffer_pitch * gp->res.height;
const s32 depth_buffer_size = gp->depthbuffer_pitch * gp->res.height;
TRACE(TRACE_INFO, "RSX", "Buffer will be %d bytes", buffer_size);
gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip
// Allocate two buffers for the RSX to draw to the screen (double buffering)
gp->framebuffer[0] = rsx_alloc(&gp->gr, buffer_size, 16);
gp->framebuffer[1] = rsx_alloc(&gp->gr, buffer_size, 16);
TRACE(TRACE_INFO, "RSX", "Buffers at 0x%x 0x%x\n",
gp->framebuffer[0], gp->framebuffer[1]);
gp->depthbuffer = rsx_alloc(&gp->gr, depth_buffer_size * 4, 16);
// Setup the display buffers
gcmSetDisplayBuffer(0, gp->framebuffer[0],
gp->framebuffer_pitch, gp->res.width, gp->res.height);
gcmSetDisplayBuffer(1, gp->framebuffer[1],
gp->framebuffer_pitch, gp->res.width, gp->res.height);
gcmResetFlipStatus();
flip(gp, 1);
}
void rotate90(Mat& src, Mat& dst) {
dst = src.t();
dst = flip(dst,dst,1);
}
