// ###################################################################### int main(const int argc, const char **argv) { MYLOGVERB = LOG_INFO; // suppress debug messages volatile int signum = 0; catchsignals(&signum); ModelManager manager("Test Motion Energy"); nub::ref<InputFrameSeries> ifs(new InputFrameSeries(manager)); manager.addSubComponent(ifs); nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(manager)); manager.addSubComponent(ofs); nub::ref<FoeDetector> fd(new FoeDetector(manager)); manager.addSubComponent(fd); if (manager.parseCommandLine((const int)argc, (const char**)argv, "<stimuli> <options>", 0, 9) == false) return(1); fd->reset(NUM_PYR_LEVEL, NUM_DIRS, NUM_SPEEDS); std::string stimuli("Image"); if(manager.numExtraArgs() > 0) stimuli = manager.getExtraArgAs<std::string>(0); LINFO("Stimuli: %s", stimuli.c_str()); manager.start(); Timer timer(1000000); timer.reset(); // reset the timer int frame = 0; PauseWaiter p; uint step; step = 0; // to get to the good part //for(uint i = 0; i < 50; i++) //was 25 // ifs->updateNext(); // get ground truth file std::string gtFilename ("/lab/tmpib/u/siagian/neuroscience/Data/FOE/driving_nat_Browning.txt"); std::vector<Point2D<int> > gt = getGT(gtFilename); int ldpos = gtFilename.find_last_of('.'); std::string prefix = gtFilename.substr(0, ldpos); // for finding ground truth rutz::shared_ptr<XWinManaged> win; float totalErr = 0.0; std::vector<std::string> args; for(uint i = 0; i < manager.numExtraArgs(); i++) args.push_back(manager.getExtraArgAs<std::string>(i)); Image<byte> prevLum; Image<PixRGB<byte> > prevImage; Image<PixRGB<byte> > prevImage2; while (1) { if (signum != 0) { LINFO("quitting because %s was caught", signame(signum)); break; } if (ofs->becameVoid()) { LINFO("quitting because output stream was closed or became void"); break; } if (p.checkPause()) continue; const FrameState is = ifs->updateNext(); if (is == FRAME_COMPLETE) break; // done receiving frames Image< PixRGB<byte> > input = ifs->readRGB(); if(frame == 0) { uint width = input.getWidth(); uint height = input.getHeight(); win.reset(new XWinManaged(Dims(width, height), 0, 0, "GT")); } // empty image signifies end-of-stream if (!input.initialized()) break; Image<byte> lum = luminance(input); Point2D<float> pshift(0.0,0.0); if(step != 0) { // calculate planar shift using SIFT lum = calculateShift(lum,prevLum, ofs); } if( manager.numExtraArgs() > 0) lum = getImage(stimuli, args, fd, step); // for saving videos prevImage2 = prevImage; prevImage = input; if (!lum.initialized()) break; step++; // compute the focus of expansion (FOE) Point2D<int> foe = fd->getFoe(lum, FOE_METHOD_TEMPLATE, false); //Point2D<int> foe = fd->getFoe(lum, FOE_METHOD_AVERAGE); LINFO("[%d]Foe: %d %d", frame, foe.i, foe.j); // illustration of the size of the receptive field if(!stimuli.compare("ShowRF")) { uint rfI = 44; uint rfJ = 152; lum.setVal(rfI, rfJ, 300.0F); drawRect(lum, Rectangle::tlbrI(144,36,159,51), byte(255)); drawRect(lum, Rectangle::tlbrI(148,40,155,47), byte(255)); drawRect(lum, Rectangle::tlbrI(rfJ-8, rfI-8, rfJ+8, rfI+8), byte(255)); drawRect(lum, Rectangle::tlbrI(rfJ-16,rfI-16,rfJ+16,rfI+16), byte(255)); } ofs->writeGrayLayout(fd->getMTfeaturesDisplay(lum), "MT Features", FrameInfo("motion energy output images", SRC_POS)); // write the file if(frame >= 4) { float err = foe.distance(gt[frame-2]); totalErr += err; LINFO("Foe: %d %d: GT: %d %d --> %f --> avg: %f", foe.i, foe.j, gt[frame-2].i, gt[frame-2].j, err, totalErr/(frame-3)); Image<PixRGB<byte> > simg = prevImage2; drawCross(simg, foe , PixRGB<byte>(0,255,0), 10, 2); drawCross(simg, gt[frame-2], PixRGB<byte>(255,0,0), 10, 2); win->drawImage(simg,0,0); //Raster::WriteRGB(simg, sformat("%s_STnPS_%06d.ppm", prefix.c_str(), frame-2)); } //ofs->writeGrayLayout // (lum, "test-FOE Main", FrameInfo("foe output", SRC_POS)); const FrameState os = ofs->updateNext(); //LINFO("frame[%d]: %8.3f %8.3f", frame, pshift.i, pshift.j); Raster::waitForKey(); if (os == FRAME_FINAL) break; prevLum = lum; frame++; } LINFO("%d frames in %gs (%.2ffps)\n", frame, timer.getSecs(), frame / timer.getSecs()); // stop all our ModelComponents manager.stop(); // all done! return 0; }
/* * Append a character to the line buffer. * Expand tabs into spaces, handle underlining, boldfacing, etc. * Returns 0 if ok, 1 if couldn't fit in buffer. */ int pappend(char c, off_t pos) { int r; if (pendc) { if (do_append(pendc, NULL, pendpos)) /* * Oops. We've probably lost the char which * was in pendc, since caller won't back up. */ return (1); pendc = '\0'; } if (c == '\r' && bs_mode == BS_SPECIAL) { if (mbc_buf_len > 0) /* utf_mode must be on. */ { /* Flush incomplete (truncated) sequence. */ r = flush_mbc_buf(mbc_pos); mbc_buf_index = r + 1; mbc_buf_len = 0; if (r) return (mbc_buf_index); } /* * Don't put the CR into the buffer until we see * the next char. If the next char is a newline, * discard the CR. */ pendc = c; pendpos = pos; return (0); } if (!utf_mode) { r = do_append((LWCHAR) c, NULL, pos); } else { /* Perform strict validation in all possible cases. */ if (mbc_buf_len == 0) { retry: mbc_buf_index = 1; *mbc_buf = c; if (IS_ASCII_OCTET(c)) { r = do_append((LWCHAR) c, NULL, pos); } else if (IS_UTF8_LEAD(c)) { mbc_buf_len = utf_len(c); mbc_pos = pos; return (0); } else { /* UTF8_INVALID or stray UTF8_TRAIL */ r = flush_mbc_buf(pos); } } else if (IS_UTF8_TRAIL(c)) { mbc_buf[mbc_buf_index++] = c; if (mbc_buf_index < mbc_buf_len) return (0); if (is_utf8_well_formed(mbc_buf)) r = do_append(get_wchar(mbc_buf), mbc_buf, mbc_pos); else /* Complete, but not shortest form, sequence. */ mbc_buf_index = r = flush_mbc_buf(mbc_pos); mbc_buf_len = 0; } else { /* Flush incomplete (truncated) sequence. */ r = flush_mbc_buf(mbc_pos); mbc_buf_index = r + 1; mbc_buf_len = 0; /* Handle new char. */ if (!r) goto retry; } } /* * If we need to shift the line, do it. * But wait until we get to at least the middle of the screen, * so shifting it doesn't affect the chars we're currently * pappending. (Bold & underline can get messed up otherwise.) */ if (cshift < hshift && column > sc_width / 2) { linebuf[curr] = '\0'; pshift(hshift - cshift); } if (r) { /* How many chars should caller back up? */ r = (!utf_mode) ? 1 : mbc_buf_index; } return (r); }
/* * Terminate the line in the line buffer. */ void pdone(int endline, int forw) { (void) pflushmbc(); if (pendc && (pendc != '\r' || !endline)) /* * If we had a pending character, put it in the buffer. * But discard a pending CR if we are at end of line * (that is, discard the CR in a CR/LF sequence). */ (void) do_append(pendc, NULL, pendpos); /* * Make sure we've shifted the line, if we need to. */ if (cshift < hshift) pshift(hshift - cshift); if (ctldisp == OPT_ONPLUS && is_ansi_end('m')) { /* Switch to normal attribute at end of line. */ char *p = "\033[m"; for (; *p != '\0'; p++) { linebuf[curr] = *p; attr[curr++] = AT_ANSI; } } /* * Add a newline if necessary, * and append a '\0' to the end of the line. * We output a newline if we're not at the right edge of the screen, * or if the terminal doesn't auto wrap, * or if this is really the end of the line AND the terminal ignores * a newline at the right edge. * (In the last case we don't want to output a newline if the terminal * doesn't ignore it since that would produce an extra blank line. * But we do want to output a newline if the terminal ignores it in case * the next line is blank. In that case the single newline output for * that blank line would be ignored!) */ if (column < sc_width || !auto_wrap || (endline && ignaw) || ctldisp == OPT_ON) { linebuf[curr] = '\n'; attr[curr] = AT_NORMAL; curr++; } else if (ignaw && column >= sc_width && forw) { /* * Terminals with "ignaw" don't wrap until they *really* need * to, i.e. when the character *after* the last one to fit on a * line is output. But they are too hard to deal with when they * get in the state where a full screen width of characters * have been output but the cursor is sitting on the right edge * instead of at the start of the next line. * So we nudge them into wrapping by outputting a space * character plus a backspace. But do this only if moving * forward; if we're moving backward and drawing this line at * the top of the screen, the space would overwrite the first * char on the next line. We don't need to do this "nudge" * at the top of the screen anyway. */ linebuf[curr] = ' '; attr[curr++] = AT_NORMAL; linebuf[curr] = '\b'; attr[curr++] = AT_NORMAL; } linebuf[curr] = '\0'; attr[curr] = AT_NORMAL; }
void pshift_all(void) { pshift(column); }