wang.cpp

#include "wang.h"
#include "mix.h"
#include "create.h"

//ìàêðîñ èíèöèàëèçàöèè ìàññèâà
#define DIRECTION_INIT( par1, c1, c2, c3, c4 ) par1[0] = c1; par1[1] = c2; par1[2] = c3; par1[3] = c4;

//ìàêðîñ âûâîäà èìåíè ïåðåìåííîé è åå çíà÷åíèÿ íà ýêðàí
#define OUTPUT( var ) std::cout << #var << "=" << var << std::endl;

//èíèöèàëèçàòîð
void Wang::init(osg::Image* image, int outputWidth, int outputHeight, int wangSize, int overlapPixels)
{
	Weave::init(image);

	_outputWidth = outputWidth;
	_outputHeight = outputHeight;

	_wangSize = wangSize;
	_patchSize = wangSize / sqrt(2);
	_patchStep = 35;
	_overlapPixels = overlapPixels;

	OUTPUT(_outputWidth);
	OUTPUT(_outputHeight);
	OUTPUT(_wangSize);
	OUTPUT(_patchSize);
	OUTPUT(_overlapPixels);

	DIRECTION_INIT(_direction[0], Red, Blue, Blue, Red); //íèæíèé, ïðàâûé, ëåâûé, âåðõíèé
	DIRECTION_INIT(_direction[1], Red, Blue, Yellow, Red);
	DIRECTION_INIT(_direction[2], Green, Blue, Blue, Red);
	DIRECTION_INIT(_direction[3], Green, Blue, Yellow, Red);
	DIRECTION_INIT(_direction[4], Red, Yellow, Blue, Red);
	DIRECTION_INIT(_direction[5], Red, Yellow, Yellow, Red);
	DIRECTION_INIT(_direction[6], Green, Yellow, Blue, Red);
	DIRECTION_INIT(_direction[7], Green, Yellow, Yellow, Red);
	DIRECTION_INIT(_direction[8], Red, Blue, Blue, Green);
	DIRECTION_INIT(_direction[9], Red, Blue, Yellow, Green);
	DIRECTION_INIT(_direction[10], Green, Blue, Blue, Green);
	DIRECTION_INIT(_direction[11], Green, Blue, Yellow, Green);
	DIRECTION_INIT(_direction[12], Red, Yellow, Blue, Green);
	DIRECTION_INIT(_direction[13], Red, Yellow, Yellow, Green);
	DIRECTION_INIT(_direction[14], Green, Yellow, Blue, Green);
	DIRECTION_INIT(_direction[15], Green, Yellow, Yellow, Green);

}


//ãëàâíûå ôóíêöèè
void Wang::run()
{
	this->createPatches();
	this->createWangTiles();
}
void Wang::createPatches()
{
	srand(time(NULL));

	//ïîëó÷àåì äàííûå îá èçîáðàæåíèè
	int imgWidth = _image->s();
	int imgHeight = _image->t();

	int startX, stopX;
	int startY, stopY;

	std::cout << "\n1. Ïîëó÷àåì ïàò÷è.\n\n";
	//èçâëåêàåì 4 ïàò÷à èç osg::image
	for (int patchNum = 0; patchNum < _wangPatchCount; patchNum++)
	{
		//ãåíåðèðóåì íà÷àëüíóþ òî÷êó
		startX = rand() % imgWidth;
		startY = rand() % imgHeight;

		//ïîëó÷àåì êîíå÷íóþ òî÷êó
		stopX = startX + (_patchSize + _overlapPixels); //_overlapPixels íóæåí äëÿ ôîðìèðîâàíèÿ çàâåäîìî áîëüøåãî èçîáðàæåíèÿ
		stopY = startY + (_patchSize + _overlapPixels); //÷òîáû âûïîëíèòü Crop è ðàçìåð ðåçóëüòàòà ñîîòâåòñâîâàë çàÿâëåííîìó

		//åñëè êîíå÷íàÿ òî÷êà íå âõîäèò â äèàïàçîí êàðòèíêè
		while (stopX > imgWidth || stopY > imgHeight)
		{
			//ãåíåðèðóåì íîâóþ òî÷êó, ÷òîáû âõîäèëà â êàðòèíêó
			startX = rand() % imgWidth;
			startY = rand() % imgHeight;

			stopX = startX + (_patchSize + _overlapPixels); //_overlapPixels íóæåí äëÿ ôîðìèðîâàíèÿ çàâåäîìî áîëüøåãî èçîáðàæåíèÿ
			stopY = startY + (_patchSize + _overlapPixels); //÷òîáû âûïîëíèòü Crop è ðàçìåð ðåçóëüòàòà ñîîòâåòñâîâàë çàÿâëåííîìó
		}

		//âûðåçàëè n-ûé ïàò÷
		osg::Image* patch = Weave::getSubImage(_image, startX, startY, stopX, stopY);

		//çàïèñàëè åãî èìÿ (íîìåð+1)
		patch->setFileName(std::to_string(patchNum + 1));

		//äîáàâèëè åãî â âåêòîð
		_wangPatches.push_back(patch);

		//âûâåëè ñîîáùåíèå íà ýêðàí
		std::cout << "Ïàò÷ ¹" << patchNum << " èçâëå÷åí;\n";
	}
	std::cout << std::endl;
	system("pause");
}
void Wang::createWangTiles()
{
	std::vector<std::vector<osg::ref_ptr<osg::Image>>> preWangTiles;

	//îáúÿâëÿåì âðåìåííûé âåêòîð äëÿ õðàíåíèÿ 4-õ òàéëîâ
	std::vector<osg::ref_ptr<osg::Image>> temp;

	std::cout << "\n2. Ôîðìèðóåì òàéëû íà îñíîâå ïàò÷åé.\n\n";
	//öèêë ôîðìèðîâàíèÿ 8 âýí-òàéëîâ
	for (int i = 0; i < _wangTilesCount; i++)
	{
		//çàïîëíÿåì âðåìåííûé âåêòîð 4-ìÿ êàðòèíêàìè
		//â íóæíîé íàì ïîñëåäîâàòåëüíîñòè
		for (int k = 0; k < _wangCmpntCount; k++)
		{
			//äîáàâëÿåì â temp íóæíûé íàì ïàò÷
			temp.push_back(_wangPatches[_direction[i][k] - 1]);
		}

		//äîáàâëÿåì â ãëàâíûé âåêòîð, âåêòîð ñ êàðòèíêàìè
		//â íóæíîé ïîñëåäîâàòåëüíîñòè (òàéë)
		preWangTiles.push_back(temp);
		temp.clear();
		std::cout << "Òàéë ¹" << i << " ñêîìáèíèðîâàí;\n";
	}
	std::cout << std::endl;
	system("pause");

	wangRotate(preWangTiles);
}















void Wang::createPatches_test()
{
	srand(time(NULL));

	//ïîëó÷àåì äàííûå îá èçîáðàæåíèè
	int imgWidth = _image->s();
	int imgHeight = _image->t();

	int patchCount = 0;
	int patchSize = _patchSize + _overlapPixels;

	int stopY = imgHeight - patchSize;
	int stopX = imgWidth - patchSize;

	for (int startY = 0; startY <= stopY; startY += _patchStep) //ïåðåáîð ïî âåðòèêàëè, ïîêà ïàò÷ íå âûëåçåò çà ïðåäåë
	{
		for (int startX = 0; startX <= stopX; startX += _patchStep) //ïåðåáîð ïî ãîðèçîíòàëè, ïîêà ïàò÷ íå âûëåçåò çà ïðåäåë
		{
			osg::Image* patch = getSubImage(_image, startX, startY, startX + patchSize, startY + patchSize); //âûðåçàåì êóñîê
			patch->setFileName(std::to_string(patchCount));	//èìåíóåì åãî
			_wangPatches.push_back(patch);	//äîáàâèëè â âåêòîð îáúåêò ïàò÷à

			//osgDB::writeImageFile(*_images[patch_count], patch_name.append(line).append(std::to_string(patch_count)).append(".bmp"));	//ñîõðàíèëè â ôàéë

			patchCount++;
			//patch_name.clear();
		}
	}
	std::cout << "Èçâëå÷åíî " << patchCount + 1 << " ïàò÷åé.\n\n";
	system("pause");
}


















//âñïîìîãàòåëüíûå ôóíêöèè
void Wang::wangRotate(std::vector<std::vector<osg::ref_ptr<osg::Image>>> & preWangTiles)
{
	std::vector<osg::ref_ptr<osg::Image>> wangRotatedTiles;
	std::cout << "\n3. Ôîðìèðóåì êîíå÷íûå âýí-òàéëû.\n\n";

#pragma region mix_data

	{
		Mix objMixingTiles;

		const int outputWidth = _patchSize * 2;
		const int outputHeight = outputWidth;

		objMixingTiles.init(_patchSize, _overlapPixels, outputWidth, outputHeight);

		for (int i = 0; i < _wangTilesCount; i++)
		{
			objMixingTiles.boundaryCut(preWangTiles[i]);
		}
	}

	std::cout << std::endl;
	system("pause");

#pragma endregion Ñìåøèâàåì ïàò÷è äëÿ ïîëó÷åíèÿ òàéëîâ


	for (int i = 0; i < _wangTilesCount; i++)
	{
		osg::Image* inputImage = preWangTiles[i][0];
		osg::ref_ptr<osg::Image> outputImage = getRotatedWang(inputImage);

		outputImage->setFileName(std::to_string(i));

		wangRotatedTiles.push_back(outputImage);
		std::cout << "Âýí-òàéë ¹" << i << " ïîâåðíóò è èçâëå÷åí;\n";

		//osgDB::writeImageFile(*inputImage, "D:\\Orion\\img\\" + inputImage->getFileName() + ".bmp");	//ñîõðàíèëè âôàéë
		//osgDB::writeImageFile(*outputImage, "D:\\Orion\\img\\" + preWangTiles[i][0]->getFileName() + "_rtd.bmp");	//ñîõðàíèëè âôàéë
	}
	wangRotatedTiles.swap(_wangTiles);

	std::cout << std::endl;
	system("pause");

	generateWangTexture();
}
void Wang::cutRotatedWangSector()
{
	struct coord
	{
		int x;
		int y;
	};

	int wangSize = _wangTiles.size();
	std::vector<osg::ref_ptr<osg::Image>> temp;
	coord startPoint, stopPoint;

	startPoint.x = _newTextureSize / 4;
	startPoint.y = startPoint.x;

	stopPoint.x = _newTextureSize - _newTextureSize / 4;
	stopPoint.y = stopPoint.x;

	for (int i = 0; i < wangSize; i++)
	{
		osg::ref_ptr<osg::Image> patch = getSubImage(_wangTiles[i], startPoint.x, startPoint.y, stopPoint.x, stopPoint.y);
		patch->setFileName(std::to_string(i));

		osgDB::writeImageFile(*patch, "D:\\Orion\\img\\" + std::to_string(i) + "_cut_.bmp");	//ñîõðàíèëè âôàéë
		temp.push_back(patch);
	}

	_wangTiles.swap(temp);
	_tileSize = _wangTiles[0]->t(); //ïîëó÷àåì ðàçìåð ñòîðîíû ôèíàëüíîãî òàéëà
	temp.clear();

	generateWangTexture();
}
void Wang::generateWangTexture()
{
#pragma region init_variables

	srand(time(NULL));

	_tileSize = _wangTiles[0]->t();

	int firstTileInLine = 0; //íîìåð ïåðâîãî òàéëà â ñòðîêå
	int lastTileInLine; //íîìåð ïîñëåäíåãî òàéëà â ñòðîêå
	int curTileLine = 1; //íîìåð òåêóùåé ñòðîêè òàéëîâ

	//êîëè÷åñòâî òàéëîâ ïî âåðòèêàëè/ãîðèçîíòàëè
	int tileColCount = _outputWidth / _tileSize;
	if (_outputWidth % _tileSize != 0) tileColCount++;

	int tileRowCount = _outputHeight / _tileSize;
	if (_outputHeight % _tileSize != 0) tileRowCount++;

	//âñåãî òàéëîâ
	int allTilesCount = tileColCount * tileRowCount;

	//êîëè÷åñòâî áàéò íà âñå òàéëû
	int allTilesByte = allTilesCount * ((_tileSize * _tileSize) * 3);

	//ìàññèâ ðåçóëüòàòà
	_test = new unsigned char[allTilesByte];

	//ñòðêòóðà õðàíåíèÿ òàéëà è èíäåêñîâ åãî ñòîðîí
	std::vector<_wangTile> wangTiles;
	_wangTile temp;

	//ïîñëåäîâàòåëüíîñòü #10 (âåðõ=íèç), íåîáõîäèìî äëÿ ñëó÷àÿ, êîãäà ñòðîêà òàéëîâ åäèíñòâåííàÿ
	int ind = rand() % _wangTilesCount;
	temp.direction = _direction[ind];

	//äîáàëâÿåì â âåêòîð ñîîòâåòñòâóþùèé ïîñëåäîâàòåëüíîñòè òàéë
	temp.tile = _wangTiles[ind];
	wangTiles.push_back(temp);

#pragma endregion Îáúÿâëÿåì ïåðåìåííûå

	std::cout << "\n4. Ôîðìèðóåì òåêñòóðó.\n";
#pragma region forming_wang_tiles

	//öèêë ïåðåáîðà âñåõ òàéëîâ, íà÷èíàÿ ñ 1, ò.ê. 0-îé óæå äîáàâëåí âûøå
	for (int j = 1; j < allTilesCount; j++)
	{
		//íîìåð òåêóùåé ñòðîêè
		if (j % tileColCount == 0) curTileLine++;

		//íîìåð ïîñëåäíåãî òàéëà â òåêóùåé ñòðîêå
		lastTileInLine = firstTileInLine + (tileColCount - 1); //íîìåð ïåðâîãî òàéëà + (îáùåå êîëè÷åñòâî òàéëîâ â ñòðîêå - 1) ò.ê. ñ íóëÿ)

#pragma region first_line

		if (j < tileColCount) //äëÿ çàïîëíåíèÿ ïåðâîé ñòðî÷êè
		{
			//èíäåêñ èñêîìîãî òàéëà
			ind = rand() % _wangTiles.size();

			//åñëè ñòðîêà íå ïîñëåäíÿÿ
			if (curTileLine != tileRowCount)
			{
				//åñëè èñêîìûé òàéë íå ïîñëåäíèé
				if (j != lastTileInLine)
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, L); //LEFT
				}
				else //åñëè òåêóùèé òàéë ïîñëåäíèé
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, LR); //LEFT-RIGHT
				}
			}
		}

#pragma endregion Äëÿ çàïîëíåíèÿ ïåðâîé ñòðî÷êè

#pragma region first_tile_fisrt_line

		else if (j % tileColCount == 0) //äëÿ ïåðâîãî ýëåìåíòà íîâîé ñòðî÷êè
		{
			firstTileInLine = j;
			ind = rand() % _wangTiles.size();

			//åñëè ñòðîêà íå ïîñëåäíÿÿ
			if (curTileLine != tileRowCount)
			{
				addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, B); //BOTTOM
			}
			//åñëè ñòðîêà ïîñëåäíÿÿ
			else
			{
				addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, BT); //BOTTOM-TOP
			}
		}

#pragma endregion Äëÿ ïåðâîãî ýëåìåíòà íîâîé ñòðî÷êè

#pragma region for_all_other

		else //äëÿ âñåõ îñòàëüíûõ
		{
			ind = rand() % _wangTiles.size();

			//åñëè ñòðîêà íå ïîñëåäíÿÿ
			if (curTileLine != tileRowCount)
			{
				//åñëè èñêîìûé òàéë íå ïîñëåäíèé
				if (j != lastTileInLine)
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, LB); //LEFT-BOTTOM
				}
				else //åñëè òåêóùèé òàéë ïîñëåäíèé
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, LRB); //LEFT-RIGHT-BOTTOM
				}
			}
			//åñëè ñòðîêà ïîñëåäíÿÿ
			else
			{
				//åñëè èñêîìûé òàéë íå ïîñëåäíèé
				if (j != lastTileInLine)
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, LBT); //LEFT-BOTTOM-TOP
				}
				else //åñëè òåêóùèé òàéë ïîñëåäíèé
				{
					addFittingTile(temp, ind, j, tileColCount, firstTileInLine, wangTiles, LRBT); //LEFT-RIGHT-BOTTOM-TOP
				}
			}

		}

#pragma endregion Äëÿ âñåõ îñòàëüíûõ

	}

#pragma endregion Âûñòðàèâàåì òàéëû â íóæíîì ïîðÿäêå

	std::cout << "\n5. Ñîõðàíÿåì â ôàéë.\n";
#pragma region save_file_wang_tiles

	//õðàíèò çíà÷åíèå ïîñëåäíåãî áàéòà â ðåçóëüòèðóþùåé êàðòèíêå
	int lastByteInTexture = allTilesByte;

	//øàã = äëèíå øèðèíå èçîáðàæåíèÿ âûñîòîé â 1 ïèêñåëü
	int rowStep = (tileColCount * _tileSize) * 3;

	//øàã = äëèíå øèðèíå èçîáðàæåíèÿ âûñîòîé â 1 òàéë
	int rowTileStep = rowStep * _tileSize;

	//øàã = øèðèíå 1 òàéëà ïî RGB-ìàñêå
	int colStep = _tileSize * 3;

	//èíäåêñ áàéòà
	int n = 0;

	//èíäåêñ òåêóùåãî òàéëà
	int tileNum = 0;;

	//îò 0 äî ïîñëåäíåãî ïèêñåëÿ ñ øàãîì â øèðèíó èçîáðàæåíèÿ âûñîòîé â òàéë
	for (int j = 0; j < lastByteInTexture; j += rowTileStep)
	{
		//öèêë äëÿ ïîñòðî÷íîé çàïèñè òàéëà â ìàññèâ
		for (int i = j; i < j + rowStep; i += colStep)
		{
			n = i;
			if (tileNum < tileColCount) //äëÿ ïåðâîé ñòðî÷êè
			{
				//ñ÷èòûâàíèå òàéëà, ïîñòðî÷íî è çàïèñü â ìàññèâ
				for (int k = 0; k < _tileSize; k++)
				{
					unsigned char* ptr = wangTiles[tileNum].tile->data(0, k);
					memcpy(_test + n, ptr, colStep);
					n = n + rowStep;
				}
			}
			else if (tileNum % tileColCount == 0) //äëÿ ïåðâîãî ýëåìåíòà ïåðâîé ñòðî÷êè
			{
				for (int k = 0; k < _tileSize; k++)
				{
					unsigned char* ptr = wangTiles[tileNum].tile->data(0, k);
					memcpy(_test + n, ptr, colStep);
					n = n + rowStep;
				}
			}
			else //äëÿ âñåõ îñòàëüíûõ
			{
				for (int k = 0; k < _tileSize; k++)
				{
					unsigned char* ptr = wangTiles[tileNum].tile->data(0, k);
					memcpy(_test + n, ptr, colStep);
					n = n + rowStep;
				}
			}
			tileNum++;
		}
	}

	//âðåìåííàÿ øèðèíà è âûñîòà èçîáðàæåíèÿ, ò.ê. áóäåò îáðåçêà
	int tempWidth = tileColCount * _tileSize;
	int tempHeight = tileRowCount * _tileSize;

	//ñîõðàíÿåì â ôàéë
	osg::Image* pImage = new osg::Image;
	pImage->setImage(tempWidth, tempHeight, 1, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, _test, osg::Image::USE_NEW_DELETE, 1);
	pImage = getSubImage(pImage, 0, 0, _outputWidth, _outputHeight);
	osgDB::writeImageFile(*pImage, "D:\\Orion\\img\\_test.bmp");	//ñîõðàíèëè â ôàéë


#pragma endregion Ñîõðàíÿåì â ôàéë êîíå÷íóþ òåêñòóðó

	std::ofstream f("D:\\out.txt");
	for (int i = 0; i < wangTiles.size(); i++)
	{
		f << wangTiles[i].tile->getFileName() << '\n';
	}
	f.close();

}

osg::ref_ptr<osg::Image> Wang::getRotatedWang(osg::ref_ptr<osg::Image> inputImage)
{
	int textureWidth = _wangSize * 2; //äèàãîíàëü òàéëà = ñòîðîíå ïîñëå ïåðåâîðîòà
	int textureHeight = textureWidth; //ò.ê. êâàäðàò

	const int t = textureWidth * sqrt(2) / 2;

	//ñòîðîíà òàéëà = ñòåïåíè 2
	osg::Image* temp = new osg::Image;
	temp->copySubImage(textureWidth - inputImage->s(), textureHeight - inputImage->s(), 0, inputImage);
	//osgDB::writeImageFile(*temp, "D:\\Orion\\img\\" + std::to_string(kkk) + ".bmp");	//ñîõðàíèëè âôàéë

	//textureWidth = textureWidth * sqrt(2);
	textureHeight = textureWidth = _wangSize;

	_newTextureSize = textureWidth;

	osgViewer::Viewer viewer;
	osg::Group* sceneGraph = new osg::Group;
	{
		//Setup rotated geometry 
		osg::ref_ptr<osg::Geode> geode = new osg::Geode();

		osg::ref_ptr<osg::Geometry> geometry = new osg::Geometry();
		geode->addDrawable(geometry);

		osg::Vec3Array& n = *(new osg::Vec3Array(1));
		n[0] = osg::Vec3(0, 0, 1);
		geometry->setNormalArray(&n, osg::Array::BIND_OVERALL);

		int diagsize = min(textureWidth / 2, textureHeight / 2);
		osg::ref_ptr<osg::Vec3Array> vertexArray = new osg::Vec3Array();
		vertexArray->push_back(osg::Vec3(_wangSize, 0, -1));
		vertexArray->push_back(osg::Vec3(_wangSize - t, t, -1));
		vertexArray->push_back(osg::Vec3(_wangSize - t * 2, 0, -1));
		vertexArray->push_back(osg::Vec3(_wangSize - t, -t, -1));
		geometry->setVertexArray(vertexArray);

		osg::ref_ptr<osg::Vec4Array> colorArray = new osg::Vec4Array();
		colorArray->push_back(osg::Vec4(1.f, 1.f, 1.f, 1.f));
		geometry->setColorArray(colorArray);
		geometry->setColorBinding(osg::Geometry::BIND_OVERALL);

		osg::ref_ptr<osg::Vec2Array> texCoordArray = new osg::Vec2Array();
		texCoordArray->push_back(osg::Vec2(1.f, 1.f));
		texCoordArray->push_back(osg::Vec2(0.f, 1.f));
		texCoordArray->push_back(osg::Vec2(0.f, 0.f));
		texCoordArray->push_back(osg::Vec2(1.f, 0.f));

		geometry->setTexCoordArray(0, texCoordArray);

		geometry->addPrimitiveSet(new osg::DrawArrays(GL_TRIANGLE_FAN, 0, 4));

		if (temp != NULL)
		{
			osg::ref_ptr<osg::Texture2D> texture2D = new osg::Texture2D();
			texture2D->setImage(temp);
			geode->getOrCreateStateSet()->setTextureAttributeAndModes(
				0, texture2D, osg::StateAttribute::ON);
		}

		geode->getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
		geode->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
		sceneGraph->addChild(geode);

	}

	//Setup camera
	osg::Vec4 clearColor(0, 0, 0, 1);
	osg::Camera* camera = viewer.getCamera();
	camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
	camera->setProjectionMatrixAsOrtho2D(-textureHeight / 2, textureHeight / 2, -textureWidth / 2, textureWidth / 2);
	camera->setViewMatrixAsLookAt(osg::Vec3(0.0f, 0.0f, 1.0f), osg::Vec3(0, 0, 0), osg::Vec3(0.0f, 1.0f, 0.0f));
	camera->setViewport(0, 0, textureWidth, textureHeight);
	camera->setClearColor(clearColor);
	camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
	camera->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	//Create the texture image
	osg::ref_ptr<osg::Image> outputImage = new osg::Image();
	outputImage->allocateImage(textureWidth,
		textureHeight,
		1,   // 2D texture is 1 pixel deep
		GL_RGB,
		GL_UNSIGNED_BYTE);
	outputImage->setInternalTextureFormat(GL_RGB8);
	camera->attach(osg::Camera::COLOR_BUFFER, outputImage.get(), 0, 0);

	{
		//Setup graphics context for offsreen rendering
		osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
		traits->x = 0;
		traits->y = 0;
		traits->width = textureWidth;
		traits->height = textureHeight;
		traits->red = 8;
		traits->green = 8;
		traits->blue = 8;
		traits->alpha = 8;
		traits->depth = 24;
		traits->windowDecoration = false;
		traits->pbuffer = true;
		traits->doubleBuffer = true;
		traits->sharedContext = 0;

		osg::ref_ptr<osg::GraphicsContext> pbuffer = osg::GraphicsContext::createGraphicsContext(traits.get());
		if (pbuffer.valid())
		{
			osg::ref_ptr<osg::Camera> camera = viewer.getCamera();
			camera->setGraphicsContext(pbuffer.get());
		}
		else
		{
			std::cout << "Failed initializing pixel buffer" << std::endl;
		}
	}

	//Setup viewer
	viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
	viewer.setSceneData(sceneGraph);
	viewer.realize();

	//Make one frame	
	viewer.frame();
	//osgDB::writeImageFile(*outputImage, "D:\\Orion\\img\\" + std::to_string(kkk++) + "_rot_.bmp");	//ñîõðàíèëè âôàéë

	return outputImage;
}
void Wang::addFittingTile(_wangTile temp, int ind, int curr, int tileColCount, int firstTileInLine, std::vector<_wangTile> & wangTiles, _tileCombine c)
{
	std::random_device rd;
	std::mt19937 gen(rd());  // to seed mersenne twister.
	std::uniform_int_distribution<> dist(0, _wangTiles.size() - 1); // distribute results between 1 and 6 inclusive.

	bool clause = false;
	while (!clause)
	{
		switch (c)
		{
		case L:
#pragma region L
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right]; //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
			break;
#pragma endregion	äëÿ ïðîìåæóòî÷íîãî òàéëà ïåðâîé ñòðîêè

		case LR:
#pragma region LR
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right] //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
				&& _direction[ind][Right] == wangTiles[0].direction[Left]; //èñêîìûé òàéë (ïðàâî) = ïåðâûé òàéë ñòðîêè (ëåâî)
			break;
#pragma endregion	ïîñëåäíåãî òàéëà ïåðâîé ñòðîêè

		case B:
#pragma region B
			clause = _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top]; //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (ââåðõ)
			break;
#pragma endregion	ïåðâîãî òàéëà íîâîé ñòðîêè

		case LB:
#pragma region LB
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right] //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
				&& _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top]; //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (ââåðõ)
			break;
#pragma endregion	ïðîìåæóòî÷íîãî òàéëà êàæäîé íîâîé ñòðîêè

		case LRB:
#pragma region LRB
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right] //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
				&& _direction[ind][Right] == wangTiles[firstTileInLine].direction[Left] //èñêîìûé òàéë (ïðàâî) = ïåðâûé òàéë ñòðîêè (ëåâî)
				&& _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top]; //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (ââåðõ)
			break;
#pragma endregion	ïîñëåäíåãî òàéëà êàæäîé íîâîé ñòðîêè

		case BT:
#pragma region BT
			clause = _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top] //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (âåðõ)
				&& _direction[ind][Top] == wangTiles[curr - firstTileInLine].direction[Bottom]; //èñêîìûé òàéë (âåðõ) = ñàìûé ïåðâûé òàéë (íèç)
			break;
#pragma endregion	ïåðâîãî òàéëà ïîñëåäíåé ñòðîêè

		case LBT:
#pragma region LBT
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right] //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
				&& _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top] //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (ââåðõ)
				&& _direction[ind][Top] == wangTiles[curr - firstTileInLine].direction[Bottom];
			break;
#pragma endregion	ïðîìåæóòî÷íîãî òàéëà ïîñëåäíåé ñòðîêè

		case LRBT:
#pragma region LRBT
			clause = _direction[ind][Left] == wangTiles[curr - 1].direction[Right] //èñêîìûé òàéë (ëåâî) = ñîñåä ñëåâà (ïðàâî)
				&& _direction[ind][Right] == wangTiles[firstTileInLine].direction[Left] //èñêîìûé òàéë (ïðàâî) = ïåðâûé òàéë ñòðîêè (ëåâî)
				&& _direction[ind][Bottom] == wangTiles[curr - tileColCount].direction[Top] //èñêîìûé òàéë (íèç) = ñîñåä ñíèçó (ââåðõ)
				&& _direction[ind][Top] == wangTiles[curr - firstTileInLine].direction[Bottom];
			break;
#pragma endregion	ïîñëåäíåãî òàéëà ïîñëåäíåé ñòðîêè
		}

		if (clause)
		{
			temp.direction = _direction[ind];
			temp.tile = _wangTiles[ind];
			wangTiles.push_back(temp);

			//std::ofstream f("D:\\rnd.txt", std::ios::app);
			//f << ind << std::endl;
			//f.close();
		}
		else
		{
			ind = dist(gen);
		}
	}
}