void FrameProcessor::processStereoFrame(const Mat & frameL, const Mat & frameR, Mat & pointCloud){
Mat disparityMap, disparityMapNormalized;
Mat frameTransposedL, frameTransposedR, frameRemappedL, frameRemappedR, frameGrayscaleL, frameGrayscaleR;
Mat rotMatL = cvCreateMat(2,3,CV_32FC1);
Mat rotMatR = cvCreateMat(2,3,CV_32FC1);
// Compute rotation matrix
CvPoint2D32f centerL = cvPoint2D32f( frameL.cols/2, frameL.rows/2 );
rotMatL = getRotationMatrix2D( centerL, 90, 1 );
CvPoint2D32f centerR = cvPoint2D32f( frameR.cols/2, frameR.rows/2 );
rotMatR = getRotationMatrix2D( centerR, 90, 1 );
warpAffine(frameL, frameTransposedL, rotMatL, frameL.size() );
warpAffine(frameR, frameTransposedR, rotMatR, frameR.size() );
//transpose(frameL, frameTransposedL);
//transpose(frameR, frameTransposedR);
remap(frameTransposedL, frameRemappedL, rmap[0][0], rmap[0][1], CV_INTER_LINEAR);
remap(frameTransposedR, frameRemappedR, rmap[1][0], rmap[1][1], CV_INTER_LINEAR);
//imshow("LiveFeedL",frameTransposedL);
//imshow("LiveFeedR",frameTransposedR);
cvtColor(frameRemappedL, frameGrayscaleL, CV_RGB2GRAY);
cvtColor(frameRemappedR, frameGrayscaleR, CV_RGB2GRAY);
BlockMatcher( frameGrayscaleL, frameGrayscaleR, disparityMap, CV_32F);
normalize(disparityMap, disparityMapNormalized, 0, 255, CV_MINMAX, CV_8U);
imshow("Disparity", disparityMapNormalized);
reprojectImageTo3D( disparityMap, pointCloud, Q, false);
}
int main(int argc, char** argv) {
ros::init(argc, argv, "image_undistort_node");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
std::string nodelet_name = ros::this_node::getName();
ROS_INFO_STREAM("Started " << nodelet_name << " nodelet.");
nodelet.load(nodelet_name, "image_undistort/ImageUndistortNodelet", remap,
nargv);
ros::spin();
return 0;
}
vaddr_t
VmMap::remap(paddr_t paddr, size_t siz)
{
//OUTDEBUG("[ VmMap ]");
vaddr_t vaddr = this->getFreeVAddr(paddr, siz);
cout << kernel::Console::HEX
<< "[ VmMap ] VmMap::remap() remapping paddr(0x" << (int) (paddr)
<< ") vaddr(0x" << (int) (vaddr) << ") SIZ[" << kernel::Console::DEC
<< (int) (siz) << "]\n";
vaddr = remap(paddr, vaddr, siz);
return vaddr;
}
void blockOopClass::remap(nmethod* nm, frame* fr) {
// the receiver's enclosing nmethod has been recompiled; update the
// map and scope pointer
// frame* home = scope(); // caller ensures liveness
// Map* oldMap = map();
Map* newMap = nm->blockMapFor(this);
// assert(oldMap != newMap, "maps should be different");
// can be equal for receiver block, or could have been remapped in
// one of the sending vframes
if (!newMap) ShouldNotReachHere(); // should have found new block map
remap(newMap, fr);
}
static byte getColour(byte cpuUsage, byte inMin, byte inMax, byte outMin, byte outMax)
{
return remap(
limitVal(
cpuUsage,
inMin,
inMax),
inMin,
inMax,
outMin,
outMax
);
}
ivector stringIndexer::
indexMap(stringIndexer & A) {
int i;
ivector remap(size);
for (i = 0; i < size; i++) {
if (A.htab.count(unh[i])) {
remap[i] = A.htab[unh[i]];
} else {
remap[i] = 0;
}
}
return remap;
}
bool
ConsumerToConsumer::call_remap_with_VK_PSEUDO_KEY(EventType eventType)
{
Params_KeyboardSpecialEventCallback::auto_ptr ptr(Params_KeyboardSpecialEventCallback::alloc(eventType,
FlagStatus::makeFlags(),
ConsumerKeyCode::VK_PSEUDO_KEY,
false));
if (! ptr) return false;
Params_KeyboardSpecialEventCallback& params = *ptr;
RemapConsumerParams rp(params);
return remap(rp);
}
Probability DefaultDensityStructure::survivalProbabilityImpl(Time t) const {
static GaussChebyshevIntegration integral(48);
// this stores the address of the method to integrate (so that
// we don't have to insert its full expression inside the
// integral below--it's long enough already)
Real (DefaultDensityStructure::*f)(Time) const =
&DefaultDensityStructure::defaultDensityImpl;
// the Gauss-Chebyshev quadratures integrate over [-1,1],
// hence the remapping (and the Jacobian term t/2)
Probability P = 1.0 - integral(remap(bind(f,this,_1), t)) * t/2.0;
//QL_ENSURE(P >= 0.0, "negative survival probability");
return std::max<Real>(P, 0.0);
}
/*
* Remaps a property value from 'form' to 'to'. This is done for all
* logical cores.
*/
static void
remap(lcore_t *lc,
unsigned from,
unsigned to,
getter_fn get,
setter_fn set)
{
if (lc) {
if (get(lc) == from)
set(lc, to);
remap(lc->next, from, to, get, set);
}
}
size_t __strlen(char* c) {
size_t len = 0;
do {
if (len % 0x1000 == 0) {
c = (char*)remap((puint_t)c);
}
if (*c++ == '\0')
break;
else
++len;
} while (true);
return len;
}
recChannel_t::~recChannel_t(void)
{
__CONTEXT("recChannel_t::~recChannel_t");
IBaseFilter * pFilter = NULL;
if (camInfo->getKind() == TEST)
{
looper->EndThread();
}
unmap();
camList->lookUp(sourceId)->setFree(true);
pControl->Stop();
looper->EndThread();
delete looper;
delete pSender;
remap();
int hr = 0;
// Enumerate the filters in the graph.
IEnumFilters *pEnum = NULL;
hr = pGraph->EnumFilters(&pEnum);
if (SUCCEEDED(hr))
{
IBaseFilter *pFilter = NULL;
while (S_OK == pEnum->Next(1, &pFilter, NULL))
{
pGraph->RemoveFilter(pFilter);
pFilter->Release();
pEnum->Reset();
}
pEnum->Release();
}
pControl->Release();
pEvent->Release();
pGraph->Release();
channelList->remove(getId());
rtpSession->deleteSender (getId(), "Channel deleted");
#ifdef _WINDOWS
EndThread();
TerminateThread(hThread,0);
#endif
}
bool
KeyToKey::call_remap_with_VK_PSEUDO_KEY(EventType eventType)
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(eventType,
FlagStatus::makeFlags(),
KeyCode::VK_PSEUDO_KEY,
CommonData::getcurrent_keyboardType(),
false));
if (! ptr) return false;
Params_KeyboardEventCallBack& params = *ptr;
RemapParams rp(params);
return remap(rp);
}
/** Main node entry point. */
int main(int argc, char **argv)
{
ros::init(argc, argv, "camera1394_node");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
nodelet.load("camera1394_node", "camera1394/driver", remap, nargv);
ros::spin();
return 0;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "localizer_node");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
nodelet.load("localizer", "localizer/LocalizerNodelet", remap, nargv);
ros::spin();
return 0;
}
int main(int argc, char** argv) {
ros::init(argc, argv, "zed_wrapper_node");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
nodelet.load(ros::this_node::getName(),
"zed_wrapper/ZEDWrapperNodelet",
remap, nargv);
ros::spin();
return 0;
}
void MoreAccurateMotionWobbleSuppressor::suppress(int idx, const Mat &frame, Mat &result)
{
CV_Assert(motions_ && stabilizationMotions_);
if (idx % period_ == 0)
{
result = frame;
return;
}
int k1 = idx / period_ * period_;
int k2 = std::min(k1 + period_, frameCount_ - 1);
Mat S1 = (*stabilizationMotions_)[idx];
Mat_<float> ML = S1 * getMotion(k1, idx, *motions2_) * getMotion(k1, idx, *motions_).inv() * S1.inv();
Mat_<float> MR = S1 * getMotion(idx, k2, *motions2_).inv() * getMotion(idx, k2, *motions_) * S1.inv();
mapx_.create(frame.size());
mapy_.create(frame.size());
float xl, yl, zl, wl;
float xr, yr, zr, wr;
for (int y = 0; y < frame.rows; ++y)
{
for (int x = 0; x < frame.cols; ++x)
{
xl = ML(0,0)*x + ML(0,1)*y + ML(0,2);
yl = ML(1,0)*x + ML(1,1)*y + ML(1,2);
zl = ML(2,0)*x + ML(2,1)*y + ML(2,2);
xl /= zl; yl /= zl;
wl = float(idx - k1);
xr = MR(0,0)*x + MR(0,1)*y + MR(0,2);
yr = MR(1,0)*x + MR(1,1)*y + MR(1,2);
zr = MR(2,0)*x + MR(2,1)*y + MR(2,2);
xr /= zr; yr /= zr;
wr = float(k2 - idx);
mapx_(y,x) = (wr * xl + wl * xr) / (wl + wr);
mapy_(y,x) = (wr * yl + wl * yr) / (wl + wr);
}
}
if (result.data == frame.data)
result = Mat(frame.size(), frame.type());
remap(frame, result, mapx_, mapy_, INTER_LINEAR, BORDER_REPLICATE);
}
//------------------------------------------------------------------------------
static void onTrackbar2(int, void*)
{
create_perspecive_undistortion_LUT( mapx_persp2, mapy_persp2, &o2, sf );
mapx_persp_right = Mat(mapx_persp2); // to copy the data
mapy_persp_right = Mat(mapy_persp2); // to copy the data
/*hconcat(mapx_persp_right,mapx_persp_left,mapx_persp_right);
hconcat(mapy_persp_right,mapy_persp_left,mapy_persp_right);*/
remap(src2, dst_persp2, mapx_persp_right, mapy_persp_right, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0,0) );
imshow( "rectified image2", dst_persp2 );
}
void CameraCalibration::DrawRectifiedImage(const int c_idx, const int img_idx) const
{
view[c_idx]->ActivateScissorAndClear();
Mat img = imread(data_path+"/"+calib_params[c_idx].ImageList.at(img_idx), 0);
Mat canvas(ImageSize.width, ImageSize.height, CV_8UC3);
Mat rimg;
if(!c_idx)
{
remap(img, rimg, rect_params->LeftRMAP[0], rect_params->LeftRMAP[1], CV_INTER_LINEAR);
cvtColor(rimg, canvas, CV_GRAY2RGB);
Rect vroi(cvRound(rect_params->LeftRoi.x), cvRound(rect_params->LeftRoi.y),
cvRound(rect_params->LeftRoi.width), cvRound(rect_params->LeftRoi.height));
rectangle(canvas, vroi, Scalar(0,0,255), 3, 8);
}else
{
remap(img, rimg, rect_params->RightRMAP[0], rect_params->RightRMAP[1], CV_INTER_LINEAR);
cvtColor(rimg, canvas, CV_GRAY2RGB);
Rect vroi(cvRound(rect_params->RightRoi.x), cvRound(rect_params->RightRoi.y),
cvRound(rect_params->RightRoi.width), cvRound(rect_params->RightRoi.height));
rectangle(canvas, vroi, Scalar(0,0,255), 3, 8);
}
if(!rect_params->isVerticalStereo)
for(int j=0; j<canvas.rows; j+=16)
line(canvas, Point(0, j), Point(canvas.cols, j), Scalar(0, 255, 0), 1, 8);
else
for(int j=0; j<canvas.cols; j+=16)
line(canvas, Point(j, 0), Point(j, canvas.rows), Scalar(0, 255, 0), 1, 8);
gl_img_tex->Upload(canvas.ptr<unsigned char>(), GL_RGB, GL_UNSIGNED_BYTE);
gl_img_tex->RenderToViewportFlipY();
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "tracker_mbt");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
nodelet.load
(ros::this_node::getName (), "visp_tracker/Tracker", remap, nargv);
ros::spin();
return 0;
}
bool init_tool(int argc, const char** argv, Options* opts) {
*opts = Options::parse_options(argc, argv);
if(!Options::has_required(*opts))
return false;
COLOR_ENABLED = !opts->has_opt("no-color");
FORCE_SCALE = opts->has_opt("force-scale");
SMOOTH = opts->has_opt("smooth");
SCALE_ENERGY = opts->has_opt("energy");
PRINT_SCALE = opts->has_opt("print-scale");
REPORT_PROGRESS = opts->has_opt("progress");
VLOG = std::ofstream(opts->get_opt<std::string>("vlog", "vlog.log"));
crf.label_alphabet = &alphabet_synth;
baseline_crf.label_alphabet = &alphabet_synth;
build_data(*opts);
pre_process(alphabet_synth, corpus_synth);
pre_process(alphabet_test, corpus_test);
alphabet_synth.optimize();
remap(alphabet_synth, corpus_synth);
alphabet_test.optimize();
remap(alphabet_test, corpus_test);
auto testSize = opts->get_opt<unsigned>("test-corpus-size", 10);
for(auto i = testSize; i < corpus_test.size(); i++)
corpus_eval.add(corpus_test.input(i), corpus_test.label(i));
corpus_test.set_max_size(testSize);
INFO("Synth sequences = " << corpus_synth.size());
INFO("Test sequences = " << corpus_test.size());
INFO("Eval sequences = " << corpus_eval.size());
return true;
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "pointgrey_camera_node");
// This is code based nodelet loading, the preferred nodelet launching is done through roslaunch
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
std::string nodelet_name = ros::this_node::getName();
nodelet.load(nodelet_name, "pointgrey_camera_driver/PointGreyCameraNodelet", remap, nargv);
ros::spin();
return 0;
}
/**
* サンプリング
* @param ret サンプルされたボリュームバッファ値
* @param x X位置
* @param y Y位置
* @param z Z位置
*/
void Sample(float* ret, float x, float y, float z) {
float xx = x;
float yy = y;
float zz = z;
if (m_isNonUniform) {
// remap coordinate.
if (SpacingX()->GetNum() > 0) {
xx = remap(xx, static_cast<const float*>(SpacingX()->GetBuffer()), SpacingX()->GetNum());
}
if (SpacingX()->GetNum() > 0) {
yy = remap(yy, static_cast<const float*>(SpacingY()->GetBuffer()), SpacingY()->GetNum());
}
if (SpacingX()->GetNum() > 0) {
zz = remap(zz, static_cast<const float*>(SpacingZ()->GetBuffer()), SpacingZ()->GetNum());
}
}
size_t ix = (std::min)((std::max)((size_t)(xx * Width()), (size_t)(Width()-1)), (size_t)0);
size_t iy = (std::min)((std::max)((size_t)(yy * Height()), (size_t)(Height()-1)), (size_t)0);
size_t iz = (std::min)((std::max)((size_t)(zz * Depth()), (size_t)(Depth()-1)), (size_t)0);
size_t idx = Component() * (iz * Width() * Height() + iy * Width() + ix);
const float* buf = static_cast<const float*>(m_buffer->GetBuffer());
for (size_t c = 0; c < Component(); c++) {
ret[c] = buf[idx + c];
}
}
void KBBGame::newGame()
{
int i, j;
if (running) {
bool ok;
ok = QMessageBox::warning(0, trans->translate("Warning!"),
trans->translate(
"Do you really want to give up this game?"),
trans->translate("Yes, I'm burnt out."),
trans->translate("No, not yet...") );
if (!ok) {
abortGame();
} else return;
}
gameBoard->fill( INNERBBT );
for (j = 0; j < (gr->numR()); j++) {
gameBoard->set( 0, j, OUTERBBT );
gameBoard->set( gr->numC()-1, j, OUTERBBT );
}
for (i = 0; i < (gr->numC()); i++) {
gameBoard->set( i, 0, OUTERBBT );
gameBoard->set( i, gr->numR()-1, OUTERBBT );
}
for (j = 2; j < (gr->numR()-2); j++) {
gameBoard->set( 1, j, LASERBBT );
gameBoard->set( gr->numC()-2, j, LASERBBT );
}
for (i = 2; i < (gr->numC()-2); i++) {
gameBoard->set( i, 1, LASERBBT );
gameBoard->set( i, gr->numR()-2, LASERBBT );
}
gameBoard->set( 1, 1, OUTERBBT );
gameBoard->set( 1, gr->numR()-2, OUTERBBT );
gameBoard->set( gr->numC()-2, 1, OUTERBBT );
gameBoard->set( gr->numC()-2, gr->numR()-2, OUTERBBT );
randomBalls( balls );
remap( gameBoard, gr->getGraphicBoard() );
gr->repaint( TRUE );
setScore( 0 );
detourCounter = -1;
ballsPlaced = 0;
running = TRUE;
updateStats();
emit gameRuns( running );
}
/**
* Initializes correct paging.
*
* Performs it by these steps:
*
* 1. detects max ram via detect_maxram
* 2. creates frame pool stack and array structure for all available ram
* 3. detects maxphyaddr
* 4. initializes memory mirror
* 5- deallocates old memory (frames are not returned).
*/
void initialize_physical_memory_allocation(struct multiboot_info* mboot_addr) {
__frame_lock = 0;
struct multiboot_info* msource = (struct multiboot_info*)remap((uint64_t)mboot_addr);
memcpy(&multiboot_info, msource, sizeof(struct multiboot_info));
__mem_mirror_present = false;
frame_pool = NULL;
maxram = detect_maxram(&multiboot_info);
create_frame_pool(&multiboot_info);
maxphyaddr = detect_maxphyaddr();
initialize_memory_mirror();
__mem_mirror_present = true;
}
bool UnixFilePartMMap::Next(const void** data, int* size) {
if (_error) return false;
if (!_open && !open()) return false;
if (_size == _position) return false;
if (_position < _mmap_offset || _position >= _mmap_offset + _mmap_blocksize) {
_mmap_offset = (_position/_mmap_blocksize)*_mmap_blocksize;
remap();
}
*data = (uint8_t*)_mmap + _position - _mmap_offset;
*size = _mmap_blocksize - (_position - _mmap_offset);
if (ssize_t(ssize_t(_size) - _position) < *size) {
*size = _size - _position;
}
_position += *size;
return true;
}
int main (int argc, char** argv) {
// Initialize ROS
ros::init(argc, argv, "kalman");
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
nodelet::V_string nargv;
std::string nodelet_name = ros::this_node::getName();
nodelet.load(nodelet_name, "rci_kalman/kalman_nodelet", remap, nargv);
ROS_INFO("Started kalman.");
ros::spin();
return 0;
}
void* skip(size_t amount) {
// Easy case, no remapping is needed
if (BytesRead + amount <= BlockOffset + BlockSize) {
void* out = MappedRegion + BytesRead - BlockOffset;
BytesRead += amount;
return out;
}
// Make sure data does not cross the block boundary
VERIFY(BytesRead == BlockOffset + BlockSize);
// Now, remap and read from the beginning of the block
remap();
return skip(amount);
}
void the::object::orderSort()
{
bool blend = false;
for (auto & s : surfaces) blend = blend || s.getBlending();
setBlend(blend);
if(blend)
{
for (auto & s : surfaces) s.unbind();
std::sort(surfaces.begin(), surfaces.end(),[&](the::surface l, the::surface r)
{
return (l.getRenderOrder() < r.getRenderOrder());
});
for (auto & s : surfaces) s.bind();
}
for(auto &ch : childs) ch->orderSort();
remap();
}
FileRandRead::FSP
MMapRandReadDynamic::read(size_t offset, vespalib::DataBuffer & buffer, size_t sz)
{
FSP file(_holder.get());
size_t end = offset + sz;
const char * data(static_cast<const char *>(file->MemoryMapPtr(offset)));
if ((data == nullptr) || !contains(*file, end)) {
// Must check that both start and end of file is mapped in.
remap(end);
file = _holder.get();
data = static_cast<const char *>(file->MemoryMapPtr(offset));
assert(data != nullptr);
assert(contains(*file, end));
}
vespalib::DataBuffer(data, sz).swap(buffer);
return file;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "imu_to_tf");
nodelet::V_string nargv;
for(int i=1;i<argc;++i)
{
nargv.push_back(argv[i]);
}
nodelet::Loader nodelet;
nodelet::M_string remap(ros::names::getRemappings());
std::string nodelet_name = ros::this_node::getName();
nodelet.load(nodelet_name, "rtabmap_ros/imu_to_tf", remap, nargv);
ros::spin();
return 0;
}
