int
main(int argc, char **argv)
{
if (argc != 4) {
std::cerr << "Usage: test_convert <file> <index_file> <rgb_file>" << std::endl;
exit(1);
}
CFile *ifile = new CFile(argv[1]);
CFile *ofile1 = new CFile(argv[2]);
CFile *ofile2 = new CFile(argv[3]);
CImageFileSrc src(*ifile);
CImagePtr image = CImageMgrInst->createImage(src);
if (! image)
exit(1);
image->convertToColorIndex();
image->writeXPM(ofile1);
image->convertToRGB();
image->writeBMP(ofile2);
delete ifile;
delete ofile1;
delete ofile2;
exit(0);
}
CImagePtr
CSVGFeImage::
filterImage(CImagePtr src_image)
{
if (! src_image.isValid()) return CImagePtr();
CImagePtr dst_image = src_image->dup();
CSVGFilter *filter = NULL;
CSVGObject *parent = parent_;
while (parent != NULL) {
filter = dynamic_cast<CSVGFilter *>(parent);
if (filter != NULL) break;
}
if (filter) {
CBBox2D bbox;
filter->getObject()->getBBox(bbox);
if (bbox.isSet())
dst_image->reshape(bbox.getWidth(), bbox.getHeight());
}
return dst_image;
}
int
main(int argc, char **argv)
{
CArgs args("-file:s (Image file");
args.parse(&argc, argv);
std::string filename = args.getStringArg("-file");
if (! CFile::exists(filename) || ! CFile::isRegular(filename)) {
args.usage("CXRootImage");
exit(1);
}
CXMachineInst->openDisplay("");
CImageFileSrc src(filename);
CImagePtr image = CImageMgrInst->lookupImage(src);
if (! image.isValid()) {
args.usage("CXRootImage");
exit(1);
}
setRootImage(image);
return 0;
}
extern void
setRootImage(CImagePtr &image)
{
Pixel bg = CXMachineInst->getBlackPixel();
Pixel fg = CXMachineInst->getWhitePixel();
GC gc = CXMachineInst->createGC(fg, bg);
int w = CXMachineInst->getWidth ();
int h = CXMachineInst->getHeight();
Pixmap pixmap = CXMachineInst->createXPixmap(w, h);
CXMachineInst->fillRectangle(pixmap, gc, 0, 0, w, h);
CXImage *cximage = image.cast<CXImage>();
if (cximage == NULL)
exit(1);
XImage *ximage = cximage->getXImage();
int iw = image->getWidth ();
int ih = image->getHeight();
if (iw > w) w = iw;
if (ih > h) h = ih;
int dst_x = (w - iw)/2;
int dst_y = (h - ih)/2;
Window root = CXMachineInst->getRoot();
CXMachineInst->putImage(pixmap, gc, ximage, 0, 0,
dst_x, dst_y, (uint) iw, (uint) ih);
CXMachineInst->putImage(root , gc, ximage, 0, 0,
dst_x, dst_y, (uint) iw, (uint) ih);
CXMachineInst->setWindowBackgroundPixmap(root, pixmap);
CXMachineInst->freeGC(gc);
CXMachineInst->freeXPixmap(pixmap);
CXMachineInst->clearWindow(root);
CXMachineInst->flushEvents();
const CXAtom &atom = CXMachineInst->getXSetRootIdAtom();
Pixmap pixmap1;
if (CXMachineInst->getPixmapProperty(root, atom, &pixmap1)) // delete ?
CXMachineInst->killClient(pixmap1);
CXMachineInst->deleteProperty(root, atom);
CXMachineInst->flushEvents();
}
CImagePtr LoadImageFromFile(const nstring & file)
{
CImagePtr image = CImageManager::GetSingelton().CreateNewImage(file, nstring("manual"),
file, CImageFormats::NF_DEFAULT);
image->BackHeigth();
return image;
}
//////////////////////////////////////////////////////////////////////////
// thread
unsigned __stdcall CImageManager::_LoadThread (void *param) {
CImageManager *pThis = (CImageManager *)param;
assert(pThis != NULL);
HANDLE hEvent = pThis->m_hEvents[THREAD_LOAD];
CImageLoader *pImageLoader = CImageLoader::getInstance();
for (;;) {
::WaitForSingleObject(hEvent, INFINITE);
if (pThis->m_exiting) {
break;
}
xl::CScopeLock lock(pThis);
xl::tstring fileName = pThis->getCurrentFileName();
int currIndex = pThis->getCurrIndex();
CLoadingCallback callback(currIndex, pThis);
CCachedImagePtr cachedImage = pThis->getCurrentCachedImage();
bool preloadThumbnail = cachedImage->getCachedImage() == NULL;
if (!preloadThumbnail) {
cachedImage.reset();
}
lock.unlock();
if (preloadThumbnail) {
xl::CTimerLogger logger(_T("Load thumbnail %s cost"), fileName.c_str());
if (cachedImage->loadThumbnail(true, &callback)) {
lock.lock(pThis);
if (!callback.shouldStop()) {
preloadThumbnail = false;
pThis->_TriggerEvent(EVT_THUMBNAIL_LOADED, &currIndex);
}
lock.unlock();
}
}
xl::CTimerLogger logger(_T("Load %s cost"), fileName.c_str());
CImagePtr image = pImageLoader->load(fileName, &callback);
if (image == NULL) {
// assert(callback.shouldStop());
XLTRACE(_T("**** load %s failed\n"), fileName.c_str());
} else {
lock.lock(pThis);
if (currIndex == pThis->getCurrIndex()) { // make sure the image is the "current" one
pThis->_TriggerEvent(EVT_IMAGE_LOADED, &image);
}
lock.unlock();
image.reset();
}
}
return 0;
}
void Start()
{
StartUpEngine(ST_INIT_YOURSELF);
MyImageExampleListener *listener = new MyImageExampleListener();
CImageManager::GetSingelton().AddDefaultListener(listener);
CImagePtr MainImage = LoadImageFromFile("Test.jpg");
CImagePtr Image1 = CopyImage(MainImage);
Image1->Negativity();
SaveImage(nstring("Image1.png"), Image1);
SaveImage(nstring("Image1.jpg"), Image1);
SaveImage(nstring("Image1.bmp"), Image1);
SaveImage(nstring("Image1.tif"), Image1);
SaveImage(nstring("Image1.tga"), Image1);
CImagePtr Image2 = CopyImage(Image1);
Image2->Blurring(3);
SaveImage(nstring("Image2.png"), Image2);
SaveImage(nstring("Image2.jpg"), Image2);
SaveImage(nstring("Image2.bmp"), Image2);
SaveImage(nstring("Image2.tif"), Image2);
SaveImage(nstring("Image2.tga"), Image2);
CImagePtr Image3 = CopyImage(Image2);
Image3->Negativity();
Image3->Gamma(0.5f);
SaveImage(nstring("Image3.png"), Image3);
SaveImage(nstring("Image3.jpg"), Image3);
SaveImage(nstring("Image3.bmp"), Image3);
SaveImage(nstring("Image3.tif"), Image3);
SaveImage(nstring("Image3.tga"), Image3);
MainImage->Alienifying();
SaveImage(nstring("MainImage.png"), MainImage);
SaveImage(nstring("MainImage.jpg"), MainImage);
SaveImage(nstring("MainImage.bmp"), MainImage);
SaveImage(nstring("MainImage.tif"), MainImage);
SaveImage(nstring("MainImage.tga"), MainImage);
CImageManager::GetSingelton().UnloadResourceFromHash(MainImage);
CImageManager::GetSingelton().UnloadResourceFromHash(Image1);
CImageManager::GetSingelton().UnloadResourceFromHash(Image2);
CImageManager::GetSingelton().UnloadResourceFromHash(Image3);
}
CImagePtr
CSVGFeTile::
filterImage(CImagePtr src_image)
{
CImagePtr dst_image = src_image->dup();
return dst_image;
}
CImagePtr
CSVGFeDiffuseLighting::
filterImage(CImagePtr src_image)
{
CImagePtr dst_image = src_image->dup();
return dst_image;
}
void
CSVGBuffer::
reset()
{
CSVGRenderer *renderer = getRenderer();
renderer->setDataRange(0, 0, 1, 1);
renderer->setViewMatrix(CMatrix2D(CMATRIX_TYPE_IDENTITY));
//------
CImagePtr image = renderer->getImage();
if (image.isValid())
image->setRGBAData(CRGBA(0,0,0,0));
//------
renderer->setStrokeColor(CRGBA(0,0,0,1));
renderer->setFillColor (CRGBA(0,0,0,1));
}
void CTexture::AddSubTexture(CImagePtr & image, nova::nUInt32 level, nInt32 face,
nova::nUInt32 xoff, nova::nUInt32 yoff, nova::nUInt32 zoff)
{
if(!isReady)
throw NOVA_EXP("CTexture::CreateTexture - resource not created!", BAD_OPERATION);
CTextureSurfaceListPtr plane = GetSurfaceList(face);
CHardwarePixelBufferPtr surface = plane->GetSurface(level);
CMemoryBuffer lock = surface->Lock(xoff, yoff, zoff,
image->GetWidth(), image->GetHeight(), image->GetDepth(), HWB_DYNAMIC);
image->GetBits().CopyTo(lock, image->GetBits().GetBufferSize(), 0);
surface->Unlock(lock);
for(nova::nUInt32 i = 0; i < GetListenersCount(); i++)
{
CTextureListener * lis =
dynamic_cast<CTextureListener *>(GetListener(i));
lis->AddSubTextureListener(this);
}
}
void CMyGLCanvas_DisplayWindow3D::OnPostRenderSwapBuffers(double At, wxPaintDC &dc)
{
if (m_win3D) m_win3D->internal_setRenderingFPS(At>0 ? 1.0/At : 1e9);
// If we are requested to do so, grab images to disk as they are rendered:
string grabFile = m_win3D->grabImageGetNextFile();
if (m_win3D && (!grabFile.empty() || m_win3D->isCapturingImgs()) )
{
int w,h;
dc.GetSize(&w, &h);
// create a memory DC and bitmap to capture the DC
wxMemoryDC memDC;
wxBitmap memBmp(w, h);
memDC.SelectObject(memBmp);
memDC.Blit(0,0, w,h, &dc, 0,0);
if (!grabFile.empty())
{
memBmp.SaveFile( _U(grabFile.c_str()) , wxBITMAP_TYPE_PNG );
m_win3D->internal_emitGrabImageEvent(grabFile);
}
if (m_win3D->isCapturingImgs())
{
wxImage img = memBmp.ConvertToImage();
CImagePtr pimg = mrpt::gui::wxImage2MRPTImagePtr(img);
{
mrpt::synch::CCriticalSectionLocker lock(& m_win3D->m_last_captured_img_cs );
m_win3D->m_last_captured_img = pimg;
pimg.clear_unique();
}
}
}
}
bool
CImageGIF::
readHeader(CFile *file, CImagePtr &image)
{
file->rewind();
try {
CImageGIFHeader header;
readHeader(file, image, &header);
//------
image->setType(CFILE_TYPE_IMAGE_GIF);
image->setSize(header.width, header.height);
}
catch (...) {
CImage::errorMsg("Failed to read GIF file");
return false;
}
return true;
}
static void
testCreateMask()
{
CFile *ifile = new CFile("data/transparent.xpm");
CFile *ofile = new CFile("test_mask.xpm");
CImageFileSrc src(*ifile);
CImagePtr image = CImageMgrInst->createImage(src);
if (! image)
exit(1);
CImagePtr image1 = image->createMask();
if (! image1)
exit(1);
image1->writeXPM(ofile);
delete ifile;
delete ofile;
}
CImagePtr CopyImage(const CImagePtr &image_ptr)
{
nstring name("copy_");
name.append(image_ptr->GetResName());
CImagePtr image = CImageManager::GetSingelton().CreateNewImage(name, nstring("manual"),
image_ptr->GetBits(), image_ptr->GetWidth(), image_ptr->GetHeight(),
image_ptr->GetDepth(), image_ptr->GetPixelFormat());
return image;
}
CImagePtr
CSVGFeComponentTransfer::
filterImage(CImagePtr src_image)
{
CImagePtr dst_image = src_image->dup();
ObjectList::const_iterator p1, p2;
for (p1 = childrenBegin(), p2 = childrenEnd(); p1 != p2; ++p1) {
CSVGFeFunc *func = dynamic_cast<CSVGFeFunc *>(*p1);
if (func)
dst_image = func->filterImage(dst_image);
}
return dst_image;
}
bool
CImageGIF::
read(CFile *file, CImagePtr &image)
{
CImageAnim *image_anim = createAnim(file);
if (image_anim->begin() != image_anim->end()) {
CImageFrame *frame = *(image_anim->begin());
CImagePtr ptr = frame->getImage();
image->replace(ptr);
}
delete image_anim;
return true;
}
int
main(int argc, char **argv)
{
bool flip_dir = false;
const char *format = "_%d_%d";
char *filename = 0;
char *dx_str = 0;
char *dy_str = 0;
char *sx_str = 0;
char *sy_str = 0;
for (int i = 1; i < argc; ++i) {
if (argv[i][0] == '-') {
if (strcmp(&argv[i][1], "flip_dir") == 0)
flip_dir = true;
else if (strcmp(&argv[i][1], "format") == 0) {
if (i < argc - 1)
format = argv[++i];
}
else
std::cerr << "Invalid option: " << argv[i] << std::endl;
}
else {
if (! filename) filename = argv[i];
else if (! dx_str ) dx_str = argv[i];
else if (! dy_str ) dy_str = argv[i];
else if (! sx_str ) sx_str = argv[i];
else if (! sy_str ) sy_str = argv[i];
}
}
if (! filename || ! dx_str || ! dy_str) {
std::cerr << "Usage: CImageUntile [-flip_dir] [-format <format>] "
"<ifile> <dx> <dy> [<sx>] [<sy>]" << std::endl;
exit(1);
}
CFile *ifile = new CFile(filename);
int dx = CStrUtil::toInteger(dx_str);
int dy = CStrUtil::toInteger(dy_str);
if (dx <= 0 || dy <= 0) return false;
int sx = (sx_str ? CStrUtil::toInteger(sx_str) : 0);
int sy = (sy_str ? CStrUtil::toInteger(sy_str) : 0);
CImageFileSrc src(*ifile);
CImagePtr image = CImageMgrInst->createImage(src);
if (! image.isValid())
exit(1);
CFileType type = image->getType();
int width = image->getWidth ();
int height = image->getHeight();
if (! flip_dir) {
for (int y = 0, iy = 1; y < height; y += dy + sy, ++iy) {
for (int x = 0, ix = 1; x < width; x += dx + sx, ++ix) {
CImagePtr image1 = image->subImage(x, y, dx, dy);
std::string ind_str = indToString(format, ix, iy);
std::string filename = ifile->getDir() + "/" + ifile->getBase() +
ind_str + "." + ifile->getSuffix();
image1->write(filename, type);
}
}
}
else {
for (int x = 0, ix = 1; x < width; x += dx + sx, ++ix) {
for (int y = 0, iy = 1; y < height; y += dy + sy, ++iy) {
CImagePtr image1 = image->subImage(x, y, dx, dy);
std::string ind_str = indToString(format, iy, ix);
std::string filename = ifile->getDir() + "/" + ifile->getBase() +
ind_str + "." + ifile->getSuffix();
image1->write(filename, type);
}
}
}
delete ifile;
exit(0);
}
void CNavView::drawMe (HDC hdc) {
if (m_currIndex == -1) {
return;
}
CRect rc = getClientRect();
xl::ui::CDCHandle dc(hdc);
xl::ui::CDC mdc;
mdc.CreateCompatibleDC(dc);
xl::CScopeLock lock(m_pImageManager);
CCachedImagePtr cachedImage = m_pImageManager->getCachedImage(m_currIndex);
CImagePtr image = cachedImage->getThumbnailImage();
if (image == NULL) {
cachedImage.reset();
return;
}
xl::ui::CDIBSectionPtr dib = image->getImage(0);
lock.unlock();
CSize szImage = image->getImageSize();
// draw text
CRect rcText = m_rect;
rcText.top += border.top.width + 2;
rcText.left += border.left.width + 2;
COLORREF oldColor = dc.SetTextColor(RGB(255,255,255));
dc.drawTransparentTextWithDefaultFont(m_ratio, -1, rcText, DT_LEFT);
dc.SetTextColor(oldColor);
int oldMode = dc.SetStretchBltMode(HALFTONE);
if (!m_dragable) {
CRect rcView = m_rcView;
rcView.OffsetRect(rc.left, rc.top);
m_dibView->attachToDC(mdc);
BLENDFUNCTION bf = {AC_SRC_OVER, 0, 75, 0};
dc.AlphaBlend(rcView.left, rcView.top, rcView.Width(), rcView.Height(), mdc, 0, 0, 1, 1, bf);
m_dibView->detachFromDC(mdc);
CRect rcImage = m_rcImage;
rcImage.OffsetRect(rc.left, rc.top);
dib->attachToDC(mdc);
dc.StretchBlt(rcImage.left, rcImage.top, rcImage.Width(), rcImage.Height(), mdc, 0, 0, dib->getWidth(), dib->getHeight(), SRCCOPY);
dib->detachFromDC(mdc);
} else {
CRect rcImage = m_rcImage;
rcImage.OffsetRect(rc.left, rc.top);
dib->attachToDC(mdc);
int oldMode = dc.SetStretchBltMode(HALFTONE);
dc.StretchBlt(rcImage.left, rcImage.top, rcImage.Width(), rcImage.Height(), mdc, 0, 0, dib->getWidth(), dib->getHeight(), SRCCOPY);
dc.SetStretchBltMode(oldMode);
dib->detachFromDC(mdc);
CRect rcView = m_rcView;
rcView.OffsetRect(rc.left, rc.top);
m_dibView->attachToDC(mdc);
BLENDFUNCTION bf = {AC_SRC_OVER, 0, 75, 0};
dc.AlphaBlend(rcView.left, rcView.top, rcView.Width(), rcView.Height(), mdc, 0, 0, 1, 1, bf);
m_dibView->detachFromDC(mdc);
CRect rcEdge = rcView;
dc.drawRectangle(rcEdge, 1, RGB(32,32,32), PS_SOLID);
rcEdge.DeflateRect(1, 1, 1, 1);
dc.drawRectangle(rcEdge, 1, RGB(200,200,200), PS_SOLID);
}
dc.SetStretchBltMode(oldMode);
}
bool
CImageSIX::
read(CFile *file, CImagePtr &image)
{
file->rewind();
CFileParse parse(file);
if (! parse.isChar('\033'))
return false;
parse.skipChar();
if (! parse.isChar('P'))
return false;
parse.skipChar();
// semi-colon separated values ending in 'q'
std::vector<int> parameters;
while (! parse.eof()) {
if (parse.isChar('q'))
break;
int p = parse.readChar();
parameters.push_back(p);
if (! parse.isChar(';'))
break;
parse.skipChar();
}
if (! parse.isChar('q'))
return false;
parse.skipChar();
int w = 0, h = 0;
std::vector<CRGBA> colors;
while (! parse.eof()) {
if (parse.isChar('\"')) {
parse.skipChar();
std::vector<int> parameters;
readParameters(parse, parameters);
if (parameters.size() == 4) {
w = parameters[2];
h = parameters[3];
}
}
else if (parse.isChar('#')) {
parse.skipChar();
std::vector<int> parameters;
readParameters(parse, parameters);
if (parameters.size() == 5) {
int r = parameters[2];
int g = parameters[3];
int b = parameters[4];
colors.push_back(CRGBA(r/255.0, g/255.0, b/255.0));
}
}
else {
break;
}
}
//------
image->setType(CFILE_TYPE_IMAGE_SIX);
image->setDataSize(w, h);
for (const auto &color : colors)
image->addColor(color);
uint *data = new uint [w*h];
//---
int c = 0;
int x = 0;
int y = 0;
while (! parse.eof()) {
if (parse.isChar('\033')) {
parse.skipChar();
if (parse.isChar('\\'))
break;
//data.push_back('\033');
return false;
}
// repeat data
else if (parse.isChar('!')) {
parse.skipChar();
int parameter;
if (! readParameter(parse, parameter))
break;
int d;
if (! readSixData(parse, d))
break;
for (int i = 0; i < parameter; ++i) {
for (int i = 0; i < 6; ++i) {
bool b = d & (1<<i);
if (b) data[x + (y + i)*w] = c;
}
++x;
}
}
// choose palette color
else if (parse.isChar('#')) {
parse.skipChar();
int parameter;
if (! readParameter(parse, parameter))
break;
c = parameter;
}
// carriage return
else if (parse.isChar('$')) {
parse.skipChar();
x = 0;
}
// next line
else if (parse.isChar('-')) {
parse.skipChar();
x = 0;
y += 6;
}
// add data
else {
int d;
if (! readSixData(parse, d))
break;
for (int i = 0; i < 6; ++i) {
bool b = d & (1<<i);
if (b) data[x + (y + i)*w] = c;
}
++x;
}
}
//------
image->setColorIndexData(data);
delete [] data;
//------
return true;
}
COpenGLScenePtr monoslamMRPT3DScene::writeMRPT3DScene() {
step++;
cout << step << endl;
// Save a 3D mrpt3dscene view of the mapping process:
COpenGLScenePtr mrpt3dscene = COpenGLScene::Create(); // = mrptwindows->get3DSceneAndLock();
COpenGLScenePtr mrpt3dsceneWithEllipsoid = COpenGLScene::Create(); //
COpenGLScenePtr mrpt3dsceneLocalisation = COpenGLScene::Create(); //
CPose3DPDFParticles curPDF; // current particle filter?????????
// if (SAVE_3D_SCENE) {
//mrpt3dscene = COpenGLScene::Create();
// The ground:
mrpt::opengl::CGridPlaneXYPtr groundPlane = mrpt::opengl::CGridPlaneXY::Create(-400, 400, -400, 400, 0, 5);
//mrpt::opengl::CGridPlaneXZPtr xzPlane = mrpt::opengl::CGridPlaneXZ::Create(-400, 400, -400, 400, 0, 5);
mrpt::opengl::CAxisPtr axisptr=CAxis::Create(-400,-400,-400,400,400,400,5,1,true);
axisptr->setColor(1,0.5,1);
groundPlane->setColor(0.4, 0.4, 0.4);
//xzPlane->setColor(0.4, 0.4, 0.4);
mrpt3dscene->insert(axisptr);
mrpt3dscene->insert(groundPlane);
//mrpt3dscene->insert(xzPlane);
mrpt3dsceneWithEllipsoid->insert(axisptr);
mrpt3dsceneWithEllipsoid->insert(groundPlane);
mrpt3dsceneLocalisation->insert(axisptr);
mrpt3dsceneLocalisation->insert(groundPlane);
// The camera pointing to the current robot pose:
// if (CAMERA_3DSCENE_FOLLOWS_ROBOT) {
mrpt::opengl::CCameraPtr objCam = mrpt::opengl::CCamera::Create();
CPose3D robotPose;
// robot state = state of camera
VNL::Vector<double> state = this->scene->get_xv();
VNL::Matrix<double> covState=this->scene->get_Pxx();
//draw trajectoire of robot
assign3D(&robotPose, state);
if (isSceneStart) {
// cout << "abc0" << endl;
//assign3D(&lastRobotPosition, state);
isSceneStart = false;
} else {
this->lineGroup->appendLine(state.Get(0), state.Get(1), state.Get(2),lastRobotPosition.x(), lastRobotPosition.y(), lastRobotPosition.z());
}
drawCameraStateEllipse(state,covState,mrpt3dsceneLocalisation);
// cout << "abc1" << endl;
assign3D(&lastRobotPosition, state);
// cout << "abc2" << endl;
mrpt3dscene->insert(lineGroup);
mrpt3dsceneWithEllipsoid->insert(lineGroup);
mrpt3dsceneLocalisation->insert(lineGroup);
// cout << "abc3" << endl;
// robotPose.x(state.Get(0));
// robotPose.y(state.Get(1));
// robotPose.z(state.Get(2));
//curPDF.getMean(robotPose);
// objCam->setPointingAt(robotPose);
// objCam->setAzimuthDegrees(-30);
// objCam->setElevationDegrees(30);
// mrpt3dscene->insert(objCam);
// }
vector<Feature*> listFeatures = this->scene->get_feature_list();
//this->scene->get
CPointCloudPtr pointClound = mrpt::opengl::CPointCloud::Create();
cout << "okie" << endl;
for (int i = 0; i < listFeatures.size(); i++) {
Feature* feature = listFeatures.at(i);
VNL::Vector<double> estimateY = feature->get_y();
string label(format("%d", feature->get_label()));
CTextPtr text = CText::Create();
text->setString(label);
text->setLocation(estimateY.Get(0), estimateY.Get(1), estimateY.Get(2));
mrpt3dscene->insert(text);
mrpt3dsceneWithEllipsoid->insert(text);
mrpt3dsceneLocalisation->insert(text);
if (false) {
// We know that our descriptors are image patches
ExtraData* feature_data = feature->get_identifier();
ImageMonoExtraData* patch_ptr = dynamic_cast<ImageMonoExtraData*> (feature_data);
// Where to draw the patches?
double draw_patch_x = -1, draw_patch_y = -1;
if (feature->get_selected_flag() &&
feature->get_successful_measurement_flag()) {
// If we just successfully matched this feature,
// then draw match position
draw_patch_x = feature->get_z()(0);
draw_patch_y = feature->get_z()(1);
} else {
Fully_Initialised_Feature_Measurement_Model *fully_init_fmm = dynamic_cast<Fully_Initialised_Feature_Measurement_Model*> (
feature->get_feature_measurement_model());
// Otherwise current estimated position after update
draw_patch_x = fully_init_fmm->get_hiRES()(0);
draw_patch_y = fully_init_fmm->get_hiRES()(1);
}
// Draw2DPatch(threedtool, draw_patch_x, draw_patch_y,
// BOXSIZE, *patch_ptr,
// (*it)->get_label() + 1);
//PixelMono* pxptr=patch_ptr->GetImageBuffer();
IplImage* imgpatch = cvCreateImage(cvSize(BOXSIZE, BOXSIZE), 8, 1);
uchar* ptr = (uchar*) imgpatch->imageData;
for (int i = 0; i < BOXSIZE; i++) {
for (int j = 0; j < BOXSIZE; j++) {
*ptr = patch_ptr->GetPixel(i, j).y;
ptr++;
//*ptr= (pxptr+(i*BOXSIZE+j))
}
}
CSetOfTexturedTrianglesPtr cstptr = CSetOfTexturedTriangles::Create();
//CTexturedPlanePtr txtptr=CTexturedPlane::Create();
//CTexturedObjectPtr ptr;
//CTexturedObject txtobj;
CImagePtr cimag = CImage::Create();
cimag->setFromIplImage(imgpatch);
cstptr->assignImage(*cimag);
cstptr->setLocation(estimateY.Get(0), estimateY.Get(1), estimateY.Get(2));
mrpt3dscene->insert(cstptr);
}
// CPose3D poseY;
// assign3D(&poseY, estimateY);
// mrpt3dscene->insert(poseY);
pointClound->insertPoint(estimateY.Get(0), estimateY.Get(1), estimateY.Get(2));
drawEllipse(feature,mrpt3dsceneWithEllipsoid);
}
pointClound->setColor(1,0,1);
mrpt3dscene->insert(pointClound);
mrpt3dsceneWithEllipsoid->insert(pointClound);
mrpt3dsceneLocalisation->insert(pointClound);
// // Draw the map(s):
// mrpt::opengl::CSetOfObjectsPtr objs = mrpt::opengl::CSetOfObjects::Create();
// mostLikMap->getAs3DObject(objs);
// mrpt3dscene->insert(objs);
// // Draw the robot particles:
// size_t M = mapBuilder.mapPDF.particlesCount();
// mrpt::opengl::CSetOfLinesPtr objLines = mrpt::opengl::CSetOfLines::Create();
// objLines->setColor(0, 1, 1);
// for (size_t i = 0; i < M; i++) {
// std::deque<TPose3D> path;
// mapBuilder.mapPDF.getPath(i, path);
//
// float x0 = 0, y0 = 0, z0 = 0;
// for (size_t k = 0; k < path.size(); k++) {
// objLines->appendLine(
// x0, y0, z0 + 0.001,
// path[k].x, path[k].y, path[k].z + 0.001);
// x0 = path[k].x;
// y0 = path[k].y;
// z0 = path[k].z;
// }
// }
// mrpt3dscene->insert(objLines);
// An ellipsoid:
// CPose3D lastMeanPose;
// float minDistBtwPoses = -1;
// std::deque<TPose3D> dummyPath;
// mapBuilder.mapPDF.getPath(0, dummyPath);
// for (int k = (int) dummyPath.size() - 1; k >= 0; k--) {
// CPose3DPDFParticles poseParts;
// mapBuilder.mapPDF.getEstimatedPosePDFAtTime(k, poseParts);
//
// CPose3D meanPose;
// CMatrixDouble66 COV;
// poseParts.getCovarianceAndMean(COV, meanPose);
//
// if (meanPose.distanceTo(lastMeanPose) > minDistBtwPoses) {
// CMatrixDouble33 COV3 = CMatrixDouble33(COV);
//
// minDistBtwPoses = 6 * sqrt(COV3(0, 0) + COV3(1, 1));
//
// opengl::CEllipsoidPtr objEllip = opengl::CEllipsoid::Create();
// objEllip->setLocation(meanPose.x(), meanPose.y(), meanPose.z() + 0.001);
// objEllip->setCovMatrix(COV3, COV3(2, 2) == 0 ? 2 : 3);
//
// objEllip->setColor(0, 0, 1);
// objEllip->enableDrawSolid3D(false);
// mrpt3dscene->insert(objEllip);
//
// lastMeanPose = meanPose;
// }
// }
// } // end if show or save 3D mrpt3dscene->
// if (SAVE_3D_SCENE) { // Save as file:
CFileGZOutputStream(format("%s/buildingmap_%05u.3Dscene", sceneDirPath.c_str(), step)) << *mrpt3dscene;
CFileGZOutputStream(format("%s.ellipsoid/buildingmap_ellipsoid_%05u.3Dscene", sceneDirPath.c_str(), step)) << *mrpt3dsceneWithEllipsoid;
CFileGZOutputStream(format("%s.localisation/buildingmap_localisation_%05u.3Dscene", sceneDirPath.c_str(), step)) << *mrpt3dsceneLocalisation;
//mrptwindows->unlockAccess3DScene();
// Update window, if required
//mrptwindows->forceRepaint();
return mrpt3dscene;
// }
}
int
main(int argc, char **argv)
{
if (argc < 11) {
std::cerr << "Usage: test_image_linear_gradient " <<
"<ofile> w h x1 y1 x2 y2 spread {color offset}" << std::endl;
exit(1);
}
CLinearGradient gradient;
CFile ofile(argv[1]);
int w, h;
if (! CStrUtil::toInteger(argv[2], &w) ||
! CStrUtil::toInteger(argv[3], &h))
exit(1);
double x1, y1, x2, y2;
if (! CStrUtil::toReal(argv[4], &x1) ||
! CStrUtil::toReal(argv[5], &y1) ||
! CStrUtil::toReal(argv[6], &x2) ||
! CStrUtil::toReal(argv[7], &y2))
exit(1);
if (strcmp(argv[8], "pad") == 0)
gradient.setSpread(CGRADIENT_SPREAD_PAD);
else if (strcmp(argv[8], "repeat") == 0)
gradient.setSpread(CGRADIENT_SPREAD_REPEAT);
else if (strcmp(argv[8], "reflect") == 0)
gradient.setSpread(CGRADIENT_SPREAD_REFLECT);
gradient.setLine(x1, y1, x2, y2);
int num_offsets = (argc - 9)/2;
for (int i = 0; i < num_offsets; ++i) {
CRGBA rgba = CRGBName::toRGBA(argv[2*i + 9]);
double offset;
if (! CStrUtil::toReal(argv[2*i + 10], &offset))
exit(1);
gradient.addStop(rgba, offset);
}
CImageNameSrc src("test_image_linear_gradient");
CImagePtr image = CImageMgrInst->createImage(src);
image->setDataSize(w, h);
image->linearGradient(gradient);
CFileType type = CFileUtil::getImageTypeFromName(argv[1]);
image->write(&ofile, type);
exit(0);
}
void SaveImage(const nstring & file, const CImagePtr &image_ptr)
{
CDevILCodec::GetSingelton().CodeToFile(nstring("image_test\\") + file, *(image_ptr.GetPtr()));
}
int
main(int argc, char **argv)
{
if (argc < 12) {
std::cerr << "Usage: test_image_radial_gradient " <<
"<ofile> w h xc yc r fx fy spread {color offset}" << std::endl;
exit(1);
}
CRadialGradient gradient;
CFile ofile(argv[1]);
int w, h;
if (! CStrUtil::toInteger(argv[2], &w) ||
! CStrUtil::toInteger(argv[3], &h))
exit(1);
double xc, yc, r;
if (! CStrUtil::toReal(argv[4], &xc) ||
! CStrUtil::toReal(argv[5], &yc) ||
! CStrUtil::toReal(argv[6], &r ))
exit(1);
double fx, fy;
if (! CStrUtil::toReal(argv[7], &fx) ||
! CStrUtil::toReal(argv[8], &fy))
exit(1);
gradient.setCenter(xc, yc);
gradient.setRadius(r);
gradient.setFocus (fx, fy);
if (strcmp(argv[9], "pad") == 0)
gradient.setSpread(CGRADIENT_SPREAD_PAD);
else if (strcmp(argv[9], "repeat") == 0)
gradient.setSpread(CGRADIENT_SPREAD_REPEAT);
else if (strcmp(argv[9], "reflect") == 0)
gradient.setSpread(CGRADIENT_SPREAD_REFLECT);
int num_offsets = (argc - 10)/2;
for (int i = 0; i < num_offsets; ++i) {
CRGBA rgba = CRGBName::toRGBA(argv[2*i + 10]);
double offset;
if (! CStrUtil::toReal(argv[2*i + 11], &offset))
exit(1);
gradient.addStop(rgba, offset);
}
CImageNameSrc src("test_image_radial_gradient");
CImagePtr image = CImageMgrInst->createImage(src);
image->setDataSize(w, h);
image->radialGradient(gradient);
CFileType type = CFileUtil::getImageTypeFromName(argv[1]);
image->write(&ofile, type);
exit(0);
}
bool
CImageGIF::
readAnimData(CFile *file, CImageAnim *image_anim, CImageGIFData *gif_data)
{
int inum = 0;
int delay = 0;
bool transparent = false;
uint transparent_color = 0;
int dispose = 0;
int user_input = 0;
uint file_size = file->getSize();
while (true) {
uchar id;
try {
if (! file->read(&id, 1))
break;
}
catch (...) {
break;
}
if (id == IMAGE_ID) {
++inum;
if (CImageState::getDebug())
CImage::infoMsg("Image Id");
CImageGIFImageHeader *image_header = new CImageGIFImageHeader;
try {
uchar byte1;
uchar byte2;
file->read(&byte1, 1);
file->read(&byte2, 1);
image_header->left = (byte2 << 8) | byte1;
file->read(&byte1, 1);
file->read(&byte2, 1);
image_header->top = (byte2 << 8) | byte1;
file->read(&byte1, 1);
file->read(&byte2, 1);
image_header->width = (byte2 << 8) | byte1;
file->read(&byte1, 1);
file->read(&byte2, 1);
image_header->height = (byte2 << 8) | byte1;
file->read(&image_header->flags, 1);
image_header->local_color_table = (image_header->flags >> 7) & 0x01;
image_header->interlaced = (image_header->flags >> 6) & 0x01;
image_header->colors_sorted = (image_header->flags >> 5) & 0x01;
image_header->color_bits = (image_header->flags ) & 0x07;
if (CImageState::getDebug()) {
CImage::infoMsg("Left " + std::to_string(image_header->left));
CImage::infoMsg("Top " + std::to_string(image_header->top));
CImage::infoMsg("Width " + std::to_string(image_header->width));
CImage::infoMsg("Height " + std::to_string(image_header->height));
CImage::infoMsg("Local Colors " + std::to_string(image_header->local_color_table));
CImage::infoMsg("Interlaced " + std::to_string(image_header->interlaced));
CImage::infoMsg("Colors Sorted " + std::to_string(image_header->colors_sorted));
CImage::infoMsg("Num Colors " + std::to_string(1 << (image_header->color_bits + 1)));
}
if (image_header->local_color_table &&
image_header->color_bits > 0) {
gif_data->num_local_colors = 1 << (image_header->color_bits + 1);
gif_data->local_colors = new CImageGIFColorTable [gif_data->num_local_colors];
for (int i = 0; i < gif_data->num_local_colors; ++i)
file->read((uchar *) &gif_data->local_colors[i], 3);
if (CImageState::getDebug()) {
for (int i = 0; i < gif_data->num_local_colors; ++i)
CImage::infoMsg(std::to_string(gif_data->local_colors[i].r) + " " +
std::to_string(gif_data->local_colors[i].g) + " " +
std::to_string(gif_data->local_colors[i].b));
}
}
file->read(&compress_data.code_size, 1);
compress_data.clear_code = 1 << compress_data.code_size;
compress_data.eof_code = compress_data.clear_code + 1;
compress_data.free_code = compress_data.clear_code + 2;
++compress_data.code_size;
compress_data.init_code_size = compress_data.code_size;
compress_data.max_code = 1 << compress_data.code_size;
compress_data.code_mask = compress_data.max_code - 1;
uint num_image_bytes = image_header->width*image_header->height;
uchar *data = new uchar [file_size];
uchar size;
file->read(&size, 1);
uint num_bytes_read = 0;
while (size > 0) {
while (size--) {
file->read(&data[num_bytes_read], 1);
++num_bytes_read;
}
file->read(&size, 1);
}
if (num_bytes_read < file_size)
memset(&data[num_bytes_read], 0, file_size - num_bytes_read);
//------
uchar *raw_data = new uchar [num_image_bytes];
decompressData(data, num_bytes_read, raw_data, num_image_bytes);
delete [] data;
if (image_header->interlaced)
deInterlace(raw_data, image_header);
//------
CImageNameSrc src("CImageGIF:" + file->getPath() + "/" + CStrUtil::toString(inum));
CImagePtr image = CImageMgrInst->createImage(src);
image->setType(CFILE_TYPE_IMAGE_GIF);
image->setDataSize(image_header->width, image_header->height);
int bottom = gif_data->header->height - image_header->height - image_header->top;
int right = gif_data->header->width - image_header->width - image_header->left;
image->setBorder(image_header->left, bottom, right, image_header->top);
if (gif_data->num_local_colors > 0) {
for (int i = 0; i < gif_data->num_local_colors; ++i)
image->addColorI(gif_data->local_colors[i].r,
gif_data->local_colors[i].g,
gif_data->local_colors[i].b);
}
else {
for (int i = 0; i < gif_data->num_global_colors; ++i)
image->addColorI(gif_data->global_colors[i].r,
gif_data->global_colors[i].g,
gif_data->global_colors[i].b);
image->setBackground(image->getColor(gif_data->header->background));
}
//------
if (transparent)
image->setTransparentColor(transparent_color);
//------
image->setColorIndexData(raw_data);
delete [] raw_data;
//------
CImageFrame *frame = new CImageFrame(image);
frame->setDelay(delay);
frame->setDispose(dispose);
frame->setUserInput(user_input);
image_anim->add(frame);
//------
delay = 0;
transparent = false;
transparent_color = 0;
dispose = 0;
user_input = 0;
//------
delete image_header;
image_header = 0;
}
catch (...) {
delete image_header;
CImage::errorMsg("Failed to read GIF file");
return false;
}
}
else if (id == CONTROL_ID) {
