create.cpp

#include "create.h"

//èíèöèàëèçàòîð
void Create::init(osg::Image* image, int patchSize, int overlapPixels, int patchSteps, int inputHeight, int inputWidth)
{
	Weave :: init(image);

	_patchSize = patchSize + overlapPixels;
	_overlapPixels = overlapPixels;
	_patchSteps = patchSteps;
	_inputHeight = inputHeight;
	_inputWidth = inputWidth;

	_patchColCount = ceil((double)inputWidth / (double)patchSize); //êîëè÷ñòâî ïàò÷åé ïî ñòîëáöàì
	_patchRowCount = ceil((double)inputHeight / (double)patchSize); //êîëè÷ñòâî ïàò÷åé ïî ñòðîêàì
	_patchNewCount = _patchColCount * _patchRowCount;
}

//ãëàâíûå ôóíêöèè
void Create::createPatches(std::map<int, osg::ref_ptr<osg::Image>> & images)
{
	int imageWidth = _image->s(); //øèðèíà èçîáðàæåíèÿ
	int imageHeight = _image->t(); //âûñîòà èçîáðàæåíèÿ
	int patchCount = 0; //êîëè÷åñòâî ïàò÷åé

	std::cout << "Start creating patches..." << std::endl;
	unsigned long start = clock();

#pragma omp parallel for schedule(dynamic) shared(imageHeight, imageWidth, images)  /*num_threads(2)*/
	for (int startY = 0; startY <= (imageHeight - _patchSize); startY += _patchSteps) //ïåðåáîð ïî âåðòèêàëè, ïîêà ïàò÷ íå âûëåçåò çà ïðåäåë
	{
		for (int startX = 0; startX <= (imageWidth - _patchSize); startX += _patchSteps) //ïåðåáîð ïî ãîðèçîíòàëè, ïîêà ïàò÷ íå âûëåçåò çà ïðåäåë
		{
			osg::Image* patch = getSubImage(_image, startX, startY, startX + _patchSize, startY + _patchSize); //âûðåçàåì êóñîê
			patch->setFileName(std::to_string(patchCount));	//èìåíóåì åãî
			images[patchCount++] = patch;	//äîáàâèëè â âåêòîð îáúåêò ïàò÷à
			//std::cout << "Patch # " << patchCount + 1 << " created;" << std::endl;

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

			//patchCount++;
			//patch_name.clear();
		}
	}

	unsigned long end = clock();
	std::cout << patchCount << " patches are created!" << std::endl;
	std::cout << "Time created: " << end - start << std::endl;
}
void Create::formingPatches(std::map<int, osg::ref_ptr<osg::Image>> & images, std::vector<osg::ref_ptr<osg::Image>> & formingImages)
{
	srand(time(NULL));

	long overlapErrorRight = LONG_MAX;
	long overlapErrorDown = LONG_MAX;
	long overlapErrorBoth = LONG_MAX;

	osg::ref_ptr<osg::Image> buf;

	//images[rand() % images.size()]
	formingImages.push_back(images[0]); //çàïèñü â 1 ýëåìåíò íîâîãî âåêòîðà, ëþáîãî òàéëà èç âåòîðà ïàò÷åé

	std::cout << std::endl << "Forming patches..." << std::endl;
	unsigned long start = clock();

	for (int c = 1; c < _patchNewCount; c++)
	{
		std::cout << ".";
		//=========================================================================================================================================
		//=========================================================================================================================================
		//=========================================================================================================================================

		if (c < _patchColCount) //äëÿ ïåðâîé ñòðî÷êè (îøèáêà òîëüêî ïî ïðàâîìó áîðòó)
		{
			for (int i = 0; i < images.size(); i++)
			{
				if (formingImages[c - 1] == images[i]) continue; //÷òîáû íå ïðîâåðÿòü òåêóùèé ïàò÷ ñ ñàìèì ñîáîé

				long err = overlapCompareError(formingImages[c - 1], images[i], RIGHT); //ïîëó÷èëè îøèáêó i-ãî ïàò÷à

				if (err < overlapErrorRight) //åñëè îíà ìèíèìàëüíà è ìåíüøå ãëîáàëüíîãî ìèíèìóìà
				{
					//äîáàâëÿåì åå â áóôåðíûé îáúåêò
					overlapErrorRight = err;
					buf = images[i];
				}
			}

			formingImages.push_back(buf); //âñòàâëÿåì â âåêòîð ðåçóëüòàòà
			overlapErrorRight = LONG_MAX;
			buf = 0;
		}
		//=========================================================================================================================================
		//=========================================================================================================================================
		//=========================================================================================================================================

		else if (c % _patchColCount == 0) //äëÿ 1 ýëåìàíòà êàæäîé íîâîé ñòðîêè (îøèáêà ïî íèæíåìó áîðòó)
		{
			for (int i = 0; i < images.size(); i++)
			{
				if (formingImages[c - 1] == images[i]) continue; //÷òîáû íå ïðîâåðÿòü òåêóùèé ïàò÷ ñ ñàìèì ñîáîé

				long err = overlapCompareError(formingImages[c - _patchColCount], images[i], DOWN); //ïîëó÷èëè îøèáêó i-ãî ïàò÷à

				if (err < overlapErrorDown) //åñëè îíà ìèíèìàëüíà
				{
					//äîáàâëÿåì åå â áóôåðíûé îáúåêò
					overlapErrorDown = err;
					buf = images[i];
				}
			}

			formingImages.push_back(buf); //âñòàâëÿåì â âåêòîð ðåçóëüòàòà
			overlapErrorDown = LONG_MAX;
			buf = 0;
		}

		//=========================================================================================================================================
		//=========================================================================================================================================
		//=========================================================================================================================================

		else //äëÿ âñåõ îñòàëüíûõ (îøèáêà ïî ïðàâîìó è íèæíåìó áîðòó)
		{
			for (int i = 0; i < images.size(); i++)
			{
				if (formingImages[c - 1] == images[i]) continue; //÷òîáû íå ïðîâåðÿòü òåêóùèé ïàò÷ ñ ñàìèì ñîáîé

				long err = overlapCompareError(formingImages[c - 1], images[i], RIGHT) +
					overlapCompareError(formingImages[c - _patchColCount], images[i], DOWN);

				if (err < overlapErrorBoth)
				{
					buf = images[i];
					overlapErrorBoth = err;
				}

			}

			formingImages.push_back(buf); //âñòàâëÿåì â âåêòîð ðåçóëüòàòà
			overlapErrorBoth = LONG_MAX;

			buf = 0;
		}

	}

	unsigned long end = clock();
	std::cout<< std::endl << "All patches are formed!" << std::endl;
	std::cout << "Time to forming: " << end - start << std::endl;
}

//âñïîìîãàòåëüíûå ôóíêöèè
long Create::overlapCompareError(osg::Image* firstPatch, osg::Image* secondPatch, overlap_direction c)
{
	switch (c)
	{
		case RIGHT:
		{
			osg::Image* rightPatchOverlap = getSubImage(firstPatch, _patchSize - _overlapPixels, 0, _patchSize, _patchSize); //ëåâûé îâåðëýï
			osg::Image* leftPatchOverlap = getSubImage(secondPatch, 0, 0, _overlapPixels, _patchSize); //ïðàâûé îâåðëýï

			return getOverlapError(leftPatchOverlap, rightPatchOverlap);
		}
		case DOWN:
		{
			osg::Image* upPatchOverlap = getSubImage(firstPatch, 0, _patchSize - _overlapPixels, _patchSize, _patchSize); //âåðõíèé îâåðëýï
			osg::Image* downPatchOverlap = getSubImage(secondPatch, 0, 0, _patchSize, _overlapPixels); //íèæíèé îâåðëýï

			return getOverlapError(upPatchOverlap, downPatchOverlap);
		}
	}
}
long Create::getOverlapError(osg::Image* firstOverlap, osg::Image* secondOverlap)
{
	long overlapError = 0;

	int overlapWidth = firstOverlap->s();
	int overlapHeight = firstOverlap->t();

	long overlapErrCount = overlapWidth * overlapHeight * 3;

	//int *overlapErr = new int[overlapErrCount];

	unsigned char* ptrOne = firstOverlap->data();
	unsigned char* ptrTwo = secondOverlap->data();

	for (int i = 0; i < overlapErrCount; i++)
	{
		overlapError += abs(ptrOne[i] - ptrTwo[i]);
	}

	return overlapError;
}