void testEntryRetrievalAppendLargeToFirstFileAndAppendSmallToSecond() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); { std::string testString(createLargeStringToWrite()); teasafe::TeaSafeFile entry = folder.getTeaSafeFile("picture.jpg", teasafe::OpenDisposition::buildAppendDisposition()); std::vector<uint8_t> vec(testString.begin(), testString.end()); entry.write((char*)&vec.front(), testString.length()); entry.flush(); entry.seek(0); // seek to start since retrieving from folder automatically seeks to end vec.resize(entry.fileSize()); entry.read((char*)&vec.front(), entry.fileSize()); std::string result(vec.begin(), vec.end()); } { std::string testData("some test data!"); teasafe::TeaSafeFile entry = folder.getTeaSafeFile("some.log", teasafe::OpenDisposition::buildAppendDisposition()); std::vector<uint8_t> vec(testData.begin(), testData.end()); entry.write((char*)&vec.front(), testData.length()); entry.flush(); entry.seek(0); // seek to start since retrieving from folder automatically seeks to end vec.resize(entry.fileSize()); entry.read((char*)&vec.front(), entry.fileSize()); std::string result(vec.begin(), vec.end()); ASSERT_EQUAL(result, testData, "testEntryRetrievalAppendLargeToFirstFileAndAppendSmallToSecond"); } }
void testTeaSafeFolderRetrievalAddEntries() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); teasafe::TeaSafeFolder subFolder = folder.getTeaSafeFolder("folderA"); subFolder.addTeaSafeFile("subFileA"); subFolder.addTeaSafeFile("subFileB"); subFolder.addTeaSafeFile("subFileC"); subFolder.addTeaSafeFile("subFileD"); // test root entries still intact { std::vector<teasafe::EntryInfo> entries = folder.listAllEntries(); ASSERT_EQUAL(entries.size(), 6, "testTeaSafeFolderRetrievalAddEntries: root number of entries"); std::vector<teasafe::EntryInfo>::iterator it = entries.begin(); ASSERT_EQUAL(entries[0].filename(), "test.txt", "testTeaSafeFolderRetrievalAddEntries: root filename A"); ASSERT_EQUAL(entries[1].filename(), "some.log", "testTeaSafeFolderRetrievalAddEntries: root filename B"); ASSERT_EQUAL(entries[2].filename(), "folderA", "testTeaSafeFolderRetrievalAddEntries: root filename C"); ASSERT_EQUAL(entries[3].filename(), "picture.jpg", "testTeaSafeFolderRetrievalAddEntries: root filename D"); ASSERT_EQUAL(entries[4].filename(), "vai.mp3", "testTeaSafeFolderRetrievalAddEntries: root filename E"); ASSERT_EQUAL(entries[5].filename(), "folderB", "testTeaSafeFolderRetrievalAddEntries: root filename F"); } // test sub folder entries exist { std::vector<teasafe::EntryInfo> entries = subFolder.listAllEntries(); ASSERT_EQUAL(entries.size(), 4, "testTeaSafeFolderRetrievalAddEntries: subfolder number of entries"); std::vector<teasafe::EntryInfo>::iterator it = entries.begin(); ASSERT_EQUAL(entries[0].filename(), "subFileA", "testTeaSafeFolderRetrievalAddEntries: subFolder filename A"); ASSERT_EQUAL(entries[1].filename(), "subFileB", "testTeaSafeFolderRetrievalAddEntries: subFolder filename B"); ASSERT_EQUAL(entries[2].filename(), "subFileC", "testTeaSafeFolderRetrievalAddEntries: subFolder filename C"); ASSERT_EQUAL(entries[3].filename(), "subFileD", "testTeaSafeFolderRetrievalAddEntries: subFolder filename D"); } }
static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform, sk_sp<SkImage> (*buildImage)()) { auto surface(SkSurface::MakeRasterN32Premul(10, 10)); SkCanvas* canvas = surface->getCanvas(); // SkBitmapCache is global, so other threads could be evicting our bitmaps. Loop a few times // to mitigate this risk. const unsigned kRepeatCount = 42; for (unsigned i = 0; i < kRepeatCount; ++i) { SkAutoCanvasRestore acr(canvas, true); sk_sp<SkImage> image(buildImage()); // always use high quality to ensure caching when scaled SkPaint paint; paint.setFilterQuality(kHigh_SkFilterQuality); // draw the image (with a transform, to tickle different code paths) to ensure // any associated resources get cached canvas->concat(transform); canvas->drawImage(image, 0, 0, &paint); const auto desc = SkBitmapCacheDesc::Make(image.get()); // delete the image image.reset(nullptr); // all resources should have been purged SkBitmap result; REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &result)); } }
void testListAllEntriesEmpty() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::SharedCoreIO io(createTestIO(testPath)); teasafe::TeaSafeFolder folder(io, 0, std::string("root")); std::vector<teasafe::EntryInfo> entries = folder.listAllEntries(); ASSERT_EQUAL(entries.size(), 0, "testListAllEntriesEmpty: number of entries"); }
void testRemoveEmptySubFolder() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); folder.removeTeaSafeFolder("folderA"); std::vector<teasafe::EntryInfo> entries = folder.listAllEntries(); ASSERT_EQUAL(entries.size(), 5, "testRemoveEmptySubFolder: number of entries after removal"); }
void testListFolderEntries() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); std::vector<teasafe::EntryInfo> entries = folder.listFolderEntries(); ASSERT_EQUAL(entries.size(), 2, "testListFolderEntries: number of entries"); std::vector<teasafe::EntryInfo>::iterator it = entries.begin(); ASSERT_EQUAL(entries[0].filename(), "folderA", "testListFolderEntries: filename C"); ASSERT_EQUAL(entries[1].filename(), "folderB", "testListFolderEntries: filename F"); }
Engine::Engine( int cornerX, int cornerY, int w, int h, const char *label ) : Fl_Double_Window(cornerX,cornerY,w,h,label), state(PREVIEW), framesPerCycle(50), pointsForFraming(100000), animationFraming(0.1), pointsPerFrame(20000), minimalBuiltPoints(1000), imageSavedWidth(800), imageSavedHeight(600), animationSavedWidth(160), animationSavedHeight(120), intervalFrame(40), clockNumber(true), skel2("triangle"), trueDensity(true), colored(false) { imageLarge = buildImage( w, h ); }
void testListFileEntries() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); std::vector<teasafe::EntryInfo> entries = folder.listFileEntries(); ASSERT_EQUAL(entries.size(), 4, "testListFileEntries: number of entries"); std::vector<teasafe::EntryInfo>::iterator it = entries.begin(); ASSERT_EQUAL(entries[0].filename(), "test.txt", "testListFileEntries: filename A"); ASSERT_EQUAL(entries[1].filename(), "some.log", "testListFileEntries: filename B"); ASSERT_EQUAL(entries[2].filename(), "picture.jpg", "testListFileEntries: filename D"); ASSERT_EQUAL(entries[3].filename(), "vai.mp3", "testListFileEntries: filename E"); }
void testAddEntryNameRetrieval() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); { teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); ASSERT_EQUAL(folder.getEntryInfo(0).filename(), "test.txt", "testAddEntryNameRetrieval A"); ASSERT_EQUAL(folder.getEntryInfo(1).filename(), "some.log", "testAddEntryNameRetrieval B"); ASSERT_EQUAL(folder.getEntryInfo(2).filename(), "folderA", "testAddEntryNameRetrieval B"); ASSERT_EQUAL(folder.getEntryInfo(3).filename(), "picture.jpg", "testAddEntryNameRetrieval C"); ASSERT_EQUAL(folder.getEntryInfo(4).filename(), "vai.mp3", "testAddEntryNameRetrieval D"); ASSERT_EQUAL(folder.getEntryInfo(5).filename(), "folderB", "testAddEntryNameRetrieval B"); } }
bool PNGAImageWriter::Export(QFile& file) { QImage pixmap = buildImage(); assert(pixmap.isGrayscale()); png::image<png::gray_pixel> image(pixmap.width(), pixmap.height()); for (size_t y = 0; y < image.get_height(); ++y) { for (size_t x = 0; x < image.get_width(); ++x) { QRgb pix = pixmap.pixel(x, y); assert(qIsGray(pix)); image[y][x] = png::gray_pixel(qAlpha(pix)); } } image.write(file.fileName().toStdString()); return true; }
void Engine::transition() { const int imagesWidth = ( state == SAVEMNG ) ? animationSavedWidth : w(); const int imagesHeight = ( state == SAVEMNG ) ? animationSavedHeight : h(); Skeleton skelWork( skel1.size() ); std::vector<Zoom> zooms; for ( std::vector< Image* >::const_iterator i = images.begin(); i != images.end(); ++i ) { delete *i; } images.clear(); const MinMax minmax = findFrameTransition( (int)(animationFraming*pointsForFraming) ); for ( float k=-framesPerCycle; k <= 0; ++k ) { const float rate = ( 1 - cos( M_PI*k/framesPerCycle ) ) / 2; skelWork.weightedMix( skel1, skel2, rate ); zooms.push_back( Zoom( minmax, imagesWidth, imagesHeight, skelWork.getZoomFunction(), framesPerCycle ) ); images.push_back( buildImage( imagesWidth, imagesHeight, w(), h() ) ); } int idemo = 1; const int idemoMax = 3; unsigned long timer = clock(); while ( idemo <= idemoMax ) { for ( int k = -framesPerCycle; k <= framesPerCycle-1; ++k ) { float rate = ( 1 - cos( M_PI*k/framesPerCycle ) ) / 2; skelWork.weightedMix( skel1, skel2, rate ); const int i = (k > 0)? framesPerCycle - k: k+framesPerCycle; if ( clockNumber ) { drawPoints( skelWork, zooms[i], *images[i], timer ); } else { drawPoints( skelWork, zooms[i], *images[i], pointsPerFrame ); } if ( state != ANIMATION && state != DEMO && state != SAVEMNG ) { return; } if ( state == DEMO && idemo == idemoMax && k == 0 ) { return; // break } if ( state == SAVEMNG && k == 0 ) { return; // break } } if ( state == DEMO ) { ++idemo; } } }
NoiseTexture2D::NoiseTexture2D( unsigned int pixelSize ) { _pixelSize = pixelSize; _image = new osg::Image(); buildImage(); setFilter( osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR ); setFilter( osg::Texture2D::MAG_FILTER, osg::Texture2D::LINEAR ); setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::MIRROR ); setWrap( osg::Texture2D::WRAP_T, osg::Texture2D::MIRROR ); setBorderWidth( 0 ); setInternalFormat( GL_LUMINANCE32F_ARB ); }
void Engine::rotation() { const int imagesWidth = ( state == SAVEMNG ) ? animationSavedWidth : w(); const int imagesHeight = ( state == SAVEMNG ) ? animationSavedHeight : h(); Skeleton skelWork = skel; std::vector<Zoom> zooms; for ( std::vector< Image* >::const_iterator i = images.begin(); i != images.end(); ++i ) { delete *i; } images.clear(); const MinMax minmax = findFrameRotation( (int)(animationFraming*pointsForFraming) ); for ( float k=-framesPerCycle; k <= framesPerCycle-1; ++k ) { skelWork.rotate( 2*M_PI/(2*framesPerCycle) ); zooms.push_back( Zoom( minmax, imagesWidth, imagesHeight, skelWork.getZoomFunction(), framesPerCycle ) ); images.push_back( buildImage( imagesWidth, imagesHeight, w(), h() ) ); } int idemo = 1; const int idemoMax = 2; unsigned long timer = clock(); while ( idemo <= idemoMax ) { // to avoid a shift due to bad accuracy of rotate(): skelWork = skel; for ( int k = -framesPerCycle; k <= framesPerCycle-1; ++k ) { if ( clockNumber ) { drawPoints( skelWork, zooms[k+framesPerCycle], *images[k+framesPerCycle], timer ); } else { drawPoints( skelWork, zooms[k+framesPerCycle], *images[k+framesPerCycle], pointsPerFrame ); } skelWork.rotate( 2*M_PI/(2*framesPerCycle) ); if ( state != ANIMATION && state != DEMO && state != SAVEMNG ) { return; } } if ( state == DEMO ) { ++idemo; } if ( state == SAVEMNG ) { return; // break } } }
bool DistanceFieldWriter::Export(QFile& file) { QImage pixmap = buildImage(); DistanceField * field = new DistanceField(pixmap.width(), pixmap.height()); for(int y = 0; y < pixmap.height(); y++) { const QRgb * scanline = (QRgb*)pixmap.scanLine(y); for(int x = 0; x < pixmap.width(); x++) { field->SetPixel(x, y, qAlpha(scanline[x]) <= 0); } } field->Generate(); QImage largePixmap(pixmap.width(),pixmap.height(),QImage::Format_Indexed8); largePixmap.setColorCount(256); for(int i = 0; i < 256; i++) largePixmap.setColor(i, qRgb(i,i,i)); for(int y = 0; y < pixmap.height(); y++) { for(int x = 0; x < pixmap.width(); x++) { int dist = field->GetDistance(x, y) + 128; if(dist < 0) dist = 0; if(dist > 255) dist = 255; largePixmap.setPixel(x, y, dist); } } delete field; /* Scale the large distance field down */ QImage smallPixmap = largePixmap.scaled(pixmap.width() / 16, pixmap.height() / 16, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); /* Convert the small pixmap to indexed format */ QImage small8BitPixmap(smallPixmap.width(), smallPixmap.height(), QImage::Format_Indexed8); for(int i = 0; i < 256; i++) small8BitPixmap.setColor(i, qRgb(i,i,i)); for(int y = 0; y < smallPixmap.height(); y++) { const QRgb * scanline = (QRgb*)smallPixmap.scanLine(y); for(int x = 0; x < smallPixmap.width(); x++) { small8BitPixmap.setPixel(x, y, qRed(scanline[x])); } } small8BitPixmap.save(&file, m_format.toUtf8().data()); return true; }
void FboBlending::update(bool forceUpdate){ bool modified = forceUpdate; if(_gammaTop != gammaTop || _gammaBottom != gammaBottom || _gammaLeft != gammaLeft || _gammaRight != gammaRight){ _gammaTop = gammaTop; _gammaBottom = gammaBottom; _gammaLeft = gammaLeft; _gammaRight = gammaRight; modified = true; } if(top.gammaR.g != gammaR || top.gammaG.g != gammaG || top.gammaB.g != gammaB){ top.setGamma(gammaR, gammaG, gammaB); bottom.setGamma(gammaR, gammaG, gammaB); left.setGamma(gammaR, gammaG, gammaB); right.setGamma(gammaR, gammaG, gammaB); modified = true; } if(!(_top == top)){ _top = (top); modified = true; } if(!(_bottom == bottom)){ _bottom = (bottom); modified = true; } if(!(_left == left)){ _left = (left); modified = true; } if(!(_right == right)){ _right = (right); modified = true; } if(modified){ buildImage(); //rebuild blending image! } }
void testTeaSafeFolderRetrievalAddEntriesAppendData() { long const blocks = 2048; boost::filesystem::path testPath = buildImage(m_uniquePath, blocks); teasafe::TeaSafeFolder folder = createTestFolder(testPath, blocks); teasafe::TeaSafeFolder subFolder = folder.getTeaSafeFolder("folderA"); subFolder.addTeaSafeFile("subFileA"); subFolder.addTeaSafeFile("subFileB"); subFolder.addTeaSafeFile("subFileC"); subFolder.addTeaSafeFile("subFileD"); std::string testData("some test data!"); teasafe::TeaSafeFile entry = subFolder.getTeaSafeFile("subFileB", teasafe::OpenDisposition::buildAppendDisposition()); std::vector<uint8_t> vec(testData.begin(), testData.end()); entry.write((char*)&vec.front(), testData.length()); entry.flush(); entry.seek(0); // seek to start since retrieving from folder automatically seeks to end vec.resize(entry.fileSize()); entry.read((char*)&vec.front(), entry.fileSize()); std::string result(vec.begin(), vec.end()); ASSERT_EQUAL(result, testData, "testTeaSafeFolderRetrievalAddEntriesAppendData"); }
Image(uint16_t * rawImage, const RawParameters & params, const QString& _filename) : filename(_filename) { buildImage(rawImage, params); }
void Engine::resetImage( int w, int h, int wd, int wh, int s ) { delete imageLarge; imageLarge = buildImage( w, h, wd, wh, s ); }
void Engine::zoom() { const int imagesWidth = ( state == SAVEMNG ) ? animationSavedWidth : w(); const int imagesHeight = ( state == SAVEMNG ) ? animationSavedHeight : h(); Skeleton skelSubframe; // we must check that we are not going to zoom inside the zoom function: if ( skel.selected() == 0 ) { // this section should be synchronized since the selected function // can be changed before its use by Skeleton::subframe skel.shiftSelectedFunction(1); } skelSubframe.subframe(skel); Function functionWork; const Zoom zoom( skel.findFrame( pointsForFraming, _x, _y, _color ), imagesWidth, imagesHeight, skel.getZoomFunction(), framesPerCycle ); for ( std::vector< Image* >::const_iterator i = images.begin(); i != images.end(); ++i ) { delete *i; } images.clear(); for ( int i = 0; i < framesPerCycle; ++i ) { images.push_back( buildImage( imagesWidth, imagesHeight, w(), h() ) ); } int idemo = 1; const int idemoMax = 3; unsigned long clock0 = clock(); const float dilat0 = 1.0/skelSubframe.getFunction().surface(); const float dilat1 = 1.0/skel.getFunction().surface(); const float otherDilat = 1.0/(skel.sumSurfaces() - skel.getFunction().surface()); while ( idemo <= idemoMax ) { for ( int k = 0; k < framesPerCycle; ++k ) { const float rate = (float)k / framesPerCycle; functionWork.spiralMix( skel.getFunction(), skelSubframe.getFunction(), rate ); functionWork.calculateTemp(); int pointsToCalculate = pointsPerFrame; if ( state == SAVEMNG) { // points(t) = points(0)*(1 + S/s(t) * (1/s(t) - 1/s(0))/(1/s(1) - 1/s(0)) ) pointsToCalculate = (int)( ( 1.0 + (1/functionWork.surface()-dilat0) / (dilat1-dilat0) * dilat1 / otherDilat ) * pointsPerFrame ); // to avoid explosion of computation time: if ( pointsToCalculate > 100 * pointsPerFrame ) { pointsToCalculate = 100 * pointsPerFrame; } } for ( int i = 1; clockNumber || i < pointsToCalculate; ++i ) { skel.nextPoint( _x, _y, _color ); float zx = _x; float zy = _y; functionWork.previousPoint( zx, zy, false ); zoom.toScreen( zx, zy ); images[k]->mem_plot( zoom.screenX, zoom.screenY ); images[k]->mem_coul( zoom.screenX, zoom.screenY, _color ); if ( clockNumber ) { if ( i % minimalBuiltPoints == 0 ) { const unsigned long newClock = clock(); if ( newClock - clock0 >= intervalFrame * timecv ) { clock0 = newClock; break; } } } } make_current(); images[k]->mem_draw(); if ( Fl::ready() ) { Fl::check(); } if ( state != ANIMATION && state != DEMO && state != SAVEMNG ) { return; } } if ( state == DEMO ) { ++idemo; } if ( state == SAVEMNG ) { return; } } }
int main() { //learning rate double alpha = 0.03; int maxIter = 15000; int miniBatchSize = 1000; double noiseRatio = 0.3; int inputSize = 28*28; int hiddenSize = 28; int imgWidth = 8; char *fileBuf = new char[4096]; bool ret = loadFileToBuf("ParamConfig.ini",fileBuf,4096); if(ret) { getConfigDoubleValue(fileBuf,"noiseRatio:",noiseRatio); getConfigDoubleValue(fileBuf,"alpha:",alpha); getConfigIntValue(fileBuf,"maxIter:",maxIter); getConfigIntValue(fileBuf,"miniBatchSize:",miniBatchSize); getConfigIntValue(fileBuf,"hiddenSize:",hiddenSize); getConfigIntValue(fileBuf,"inputSize:",inputSize); getConfigIntValue(fileBuf,"imgWidth:",imgWidth); cout << "noiseRatio:" << noiseRatio << endl; cout << "alpha:" << alpha << endl; cout << "maxIter:" << maxIter << endl; cout << "miniBatchSize:" << miniBatchSize << endl; cout << "hiddenSize:" << hiddenSize << endl; cout << "inputSize:" << inputSize << endl; cout << "imgWidth:" << imgWidth << endl; } delete []fileBuf; //set eigen threads SYSTEM_INFO info; GetSystemInfo(&info); Eigen::setNbThreads(info.dwNumberOfProcessors); MatrixXd trainData(1,inputSize); DAE dae(inputSize,hiddenSize); ret = loadMnistData(trainData,"mnist\\train-images-idx3-ubyte"); cout << "Loading training data..." << endl; if(ret == false) { return -1; } clock_t start = clock(); //cout << trainData.rows() << " " << trainData.cols() << endl; MatrixXd showImage = trainData.leftCols(100).transpose(); buildImage(showImage,imgWidth,"data.jpg"); dae.train(trainData,noiseRatio,alpha,maxIter,miniBatchSize); cout << "End Train" << endl; MatrixXd hiddenTheta = dae.getTheta(); buildImage(hiddenTheta,imgWidth,"weights.jpg",true); cout << "Saving hidden neurons" << endl; dae.saveModel("DAE_Model.txt"); clock_t end = clock(); cout << "The code ran for " << (end - start)/(double)(CLOCKS_PER_SEC*60) << " minutes on " << Eigen::nbThreads() << " thread(s)." << endl; cout << "noiseRatio: " << noiseRatio << endl; cout << "alpha: " << alpha << endl; cout << "miniBatchSize: " << miniBatchSize << endl; system("pause"); return 0; }