#include "tools/rasterselection.h"

#include "tools/tool.h"

#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "tpaletteutil.h"

#include "trop.h"

#include "drawutil.h"

#include "tconvert.h"

#include "timagecache.h"

#include "tpixelutils.h"

#include "toonzqt/rasterimagedata.h"

#include "toonzqt/strokesdata.h"

#include "toonzqt/selectioncommandids.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/dvdialog.h"

#include "toonz/stage.h"

#include "toonz/toonzimageutils.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/tpalettehandle.h"

#include "toonz/palettecontroller.h"

#include "toonz/toonzscene.h"

#include "toonz/tcamera.h"

#include "toonz/trasterimageutils.h"

#include "toonz/toonzimageutils.h"

#include <qapplication></qapplication>

#include <qclipboard></qclipboard>

#include "timage_io.h"

#include "tropcm.h"

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

namespace

{

//-----------------------------------------------------------------------------

TRasterP getRaster(const TImageP image)

{

	if (TToonzImageP ti = (TToonzImageP)(image))

		return ti->getRaster();

	if (TRasterImageP ri = (TRasterImageP)(image))

		return ri->getRaster();

	return (TRasterP)(0);

}

//-----------------------------------------------------------------------------

TRect convertWorldToRaster(const TRectD area, const TRasterP ras)

{

	if (area.isEmpty())

		return TRect();

	if (!ras)

		return TRect(tfloor(area.x0), tfloor(area.y0), tfloor(area.x1) - 1, tfloor(area.y1) - 1);

	TRectD rect(area + ras->getCenterD());

	return TRect(tfloor(rect.x0), tfloor(rect.y0), tceil(rect.x1) - 1, tceil(rect.y1) - 1);

}

//-----------------------------------------------------------------------------

TRect convertWorldToRaster(const TRectD area, const TImageP image)

{

	TRasterImageP ri(image);

	TToonzImageP ti(image);

	//Watch out! TToonzImage::getRaster() returns a TRasterCM32P, while

	//TRasterImage::getRaster() returns a TRasterP!

	TRasterP ras = (ri) ? ri->getRaster() : (TRasterP)ti->getRaster();

	return convertWorldToRaster(area, ras);

}

//-----------------------------------------------------------------------------

TRectD convertRasterToWorld(const TRect area, const TImageP image)

{

	TToonzImageP ti(image);

	if (ti)

		return ToonzImageUtils::convertRasterToWorld(area, image);

	return TRasterImageUtils::convertRasterToWorld(area, image);

}

//-----------------------------------------------------------------------------

TRectD intersection(const TRectD &area, const TImageP image)

{

	TToonzImageP ti(image);

	if (ti)

		return area * ToonzImageUtils::convertRasterToWorld(ti->getRaster()->getBounds(), image);

	TRasterImageP ri(image);

	if (ri)

		return area * TRasterImageUtils::convertRasterToWorld(ri->getRaster()->getBounds(), ri);

	return area;

}

//-----------------------------------------------------------------------------

//The stroke is in raster coordinates

template <class class="" pixel1,="" pixel2=""></class>

TRasterPT<pixel1> getImageFromStroke(TRasterPT<pixel2> ras, const TStroke &stroke)</pixel2></pixel1>

{

	TRectD regionsBoxD = stroke.getBBox();

	//E' volutamente allargato di un pixel!

	TRect regionsBox(tfloor(regionsBoxD.x0), tfloor(regionsBoxD.y0), tceil(regionsBoxD.x1), tceil(regionsBoxD.y1));

	regionsBox *= ras->getBounds();

	if (regionsBox.isEmpty())

		return (TRasterPT<pixel1>)0;</pixel1>

	TRasterPT<pixel1> buffer(regionsBox.getSize());</pixel1>

	buffer->clear();

	//Compute regions created by the vector

	TVectorImage app;

	app.addStroke(new TStroke(stroke));

	app.findRegions();

	int reg, j, k, y;

	ras->lock();

	for (reg = 0; reg < (int)app.getRegionCount(); reg++) {

		//For each region, pixels inside the region are copied in buffer!

		TRectD bBoxD = stroke.getBBox();

		TRect bBox(tfloor(bBoxD.x0), tfloor(bBoxD.y0), tceil(bBoxD.x1) - 1, tceil(bBoxD.y1) - 1);

		bBox *= ras->getBounds();

		for (y = bBox.y0; y <= bBox.y1; y++) {

			PIXEL2 *selectedLine = ras->pixels(y);

			int startY = y - regionsBox.y0;

			PIXEL1 *bufferLine = buffer->pixels(startY >= 0 ? startY : 0);

			vector<double> intersections;</double>

			app.getRegion(reg)->computeScanlineIntersections(y, intersections);

			if (intersections.empty())

				app.getRegion(reg)->computeScanlineIntersections(y + 0.9, intersections);

			for (j = 0; j < (int)intersections.size(); j += 2) {

				if (intersections[j] == intersections[j + 1])

					continue;

				int from = tmax(tfloor(intersections[j]), bBox.x0);

				int to = tmin(tceil(intersections[j + 1]), bBox.x1);

				for (k = from; k <= to; k++) {

					TRasterCM32P bufferCM(buffer);

					TRaster32P buffer32(buffer);

					TRasterCM32P rasCM(ras);

					TRaster32P ras32(ras);

					TRasterGR8P rasGR8(ras);

					if (bufferCM && rasCM) {

						TPixelCM32 *bottomPix = (TPixelCM32 *)bufferLine + k - regionsBox.x0;

						TPixelCM32 *topPix = (TPixelCM32 *)selectedLine + k;

						*bottomPix = *topPix;

					} else if (buffer32 && ras32) {

						TPixel32 *bottomPix = (TPixel32 *)bufferLine + k - regionsBox.x0;

						TPixel32 *topPix = (TPixel32 *)selectedLine + k;

						*bottomPix = *topPix;

					} else if (buffer32 && rasGR8) {

						TPixel32 *bottomPix = (TPixel32 *)bufferLine + k - regionsBox.x0;

						TPixelGR8 *topPix = (TPixelGR8 *)selectedLine + k;

						*bottomPix = TPixel32(topPix->value, topPix->value, topPix->value, 255);

					} else

						assert(0);

				}

			}

		}

	}

	ras->unlock();

	return buffer;

}

//-----------------------------------------------------------------------------

template <class class="" pixel1,="" pixel2=""></class>

TRasterPT<pixel1> getImageFromSelection(TRasterPT<pixel2> &ras, RasterSelection &selection)</pixel2></pixel1>

{

	if (selection.isEmpty())

		return (TRasterPT<pixel1>)0;</pixel1>

	TRectD wSelectionBound = selection.getSelectionBbox();

	TRect rSelectionBound = convertWorldToRaster(wSelectionBound, ras);

	rSelectionBound *= ras->getBounds();

	TRasterPT<pixel1> selectedRaster(rSelectionBound.getSize());</pixel1>

	selectedRaster->clear();

	vector<tstroke> strokes = selection.getStrokes();</tstroke>

	TPoint startPosition = rSelectionBound.getP00();

	unsigned int i;

	for (i = 0; i < strokes.size(); i++) {

		TStroke stroke = strokes[i];

		stroke.transform(TTranslation(ras->getCenterD()));

		TRasterPT<pixel1> app = getImageFromStroke<pixel1, pixel2="">(ras, stroke);</pixel1,></pixel1>

		if (!app)

			continue;

		TRectD strokeRectD = stroke.getBBox();

		TRect strokeRect(tfloor(strokeRectD.x0), tfloor(strokeRectD.y0), tceil(strokeRectD.x1) - 1, tceil(strokeRectD.y1) - 1);

		TPoint offset((strokeRect * rSelectionBound).getP00() - rSelectionBound.getP00());

		TPoint startP = rSelectionBound.getP00() + offset;

		startPosition = TPoint(tmin(startPosition.x, startP.x), tmin(startPosition.y, startP.y));

		TRop::over(selectedRaster, app, offset);

	}

	selection.setStartPosition(startPosition);

	return selectedRaster;

}

//-----------------------------------------------------------------------------

TRasterP getImageFromSelection(const TImageP &image, RasterSelection &selection)

{

	if (TToonzImageP toonzImage = (TToonzImageP)image) {

		TRasterPT<tpixelcm32> ras = toonzImage->getRaster();</tpixelcm32>

		return getImageFromSelection<tpixelcm32, tpixelcm32="">(ras, selection);</tpixelcm32,>

	}

	if (TRasterImageP rasterImage = (TRasterImageP)image) {

		TRasterP ras = rasterImage->getRaster();

		if (TRaster32P ras32 = (TRaster32P)ras)

			return getImageFromSelection<tpixel32, tpixel32="">(ras32, selection);</tpixel32,>

		if (TRasterGR8P rasGR8 = (TRasterGR8P)ras)

			return getImageFromSelection<tpixel32, tpixelgr8="">(rasGR8, selection);</tpixel32,>

	}

	return (TRasterP)0;

}

//-----------------------------------------------------------------------------

template <typename pixel=""></typename>

void deleteSelectionWithoutUndo(TRasterPT<pixel> &ras, const vector<tstroke> &strokes, PIXEL emptyValue)</tstroke></pixel>

{

	if (!ras)

		return;

	unsigned int i;

	for (i = 0; i < strokes.size(); i++) {

		TStroke s = strokes[i];

		s.transform(TTranslation(ras->getCenterD()));

		TRectD strokeRectD = s.getBBox();

		//E' volutamente allargato di un pixel!

		TRect strokeRect(tfloor(strokeRectD.x0), tfloor(strokeRectD.y0), tceil(strokeRectD.x1), tceil(strokeRectD.y1));

		if (!strokeRect.overlaps(ras->getBounds()))

			continue;

		//Compute regions created by the vector

		TVectorImage app;

		app.addStroke(new TStroke(s));

		app.findRegions();

		int reg, j, k, y;

		ras->lock();

		TRect rasRect(ras->getBounds());

		for (reg = 0; reg < (int)app.getRegionCount(); reg++) {

			//For each region, pixels inside the region are erased!

			TRectD bBoxD = app.getRegion(reg)->getBBox();

			TRect bBox(tfloor(bBoxD.x0), tfloor(bBoxD.y0), tceil(bBoxD.x1) - 1, tceil(bBoxD.y1) - 1);

			bBox *= rasRect;

			for (y = bBox.y0; y <= bBox.y1; y++) {

				PIXEL *selectedLine = ras->pixels(y);

				int startY = y - strokeRect.y0;

				vector<double> intersections;</double>

				app.getRegion(reg)->computeScanlineIntersections(y, intersections);

				if (intersections.empty())

					app.getRegion(reg)->computeScanlineIntersections(y + 0.9, intersections);

				for (j = 0; j < (int)intersections.size(); j += 2) {

					if (intersections[j] == intersections[j + 1])

						continue;

					int from = tmax(tfloor(intersections[j]), bBox.x0);

					int to = tmin(tceil(intersections[j + 1]), bBox.x1);

					for (k = from; k <= to; k++)

						*(selectedLine + k) = emptyValue;

				}

			}

		}

		ras->unlock();

	}

}

//-----------------------------------------------------------------------------

void deleteSelectionWithoutUndo(const TImageP &image, const vector<tstroke> &strokes)</tstroke>

{

	if (TToonzImageP toonzImage = (TToonzImageP)image) {

		TRasterPT<tpixelcm32> ras = toonzImage->getRaster();</tpixelcm32>

		deleteSelectionWithoutUndo<tpixelcm32>(ras, strokes, TPixelCM32());</tpixelcm32>

	}

	if (TRasterImageP rasterImage = (TRasterImageP)image) {

		TRasterP ras = rasterImage->getRaster();

		if (TRaster32P ras32 = (TRaster32P)ras)

			deleteSelectionWithoutUndo<tpixel32>(ras32, strokes, TPixel32::Transparent);</tpixel32>

		if (TRasterGR8P rasGR8 = (TRasterGR8P)ras)

			deleteSelectionWithoutUndo<tpixelgr8>(rasGR8, strokes, TPixelGR8::White);</tpixelgr8>

	}

}

//-----------------------------------------------------------------------------

void pasteFloatingSelectionWithoutUndo(const TImageP &image, const TRasterP &floatingSelection,

									   const TAffine &transformation, const TRectD &wSelectionBound,

									   bool noAntialiasing)

{

	TRasterImageP ri = (TRasterImageP)image;

	TToonzImageP ti = (TToonzImageP)image;

	TRasterP targetRaster = (ri) ? ri->getRaster() : (TRasterP)ti->getRaster();

	if (!targetRaster || !floatingSelection)

		return;

	TRect rSelectionBound = convertWorldToRaster(wSelectionBound, targetRaster);

	TRop::over(targetRaster, floatingSelection, rSelectionBound.getP00(), transformation,

			   noAntialiasing ? TRop::ClosestPixel : TRop::Triangle);

}

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

// UndoDeleteSelection

//-----------------------------------------------------------------------------

class UndoDeleteSelection : public TUndo

{

	static int m_id;

	TXshSimpleLevelP m_level;

	TFrameId m_frameId;

	string m_erasedImageId;

	TPoint m_erasePoint;

	vector<tstroke> m_strokes;</tstroke>

	TTool *m_tool;

public:

	UndoDeleteSelection(RasterSelection *selection, TXshSimpleLevel *level)

		: TUndo(), m_level(level), m_frameId(selection->getFrameId()), m_strokes(selection->getOriginalStrokes())

	{

		TImageP image = m_level->getFrame(m_frameId, true);

		m_erasedImageId = "UndoDeleteSelection" + toString(m_id++);

		TRasterP ras = getRaster(image);

		TRasterP erasedRas;

		if (!selection->isFloating())

			erasedRas = TRasterP(getImageFromSelection(image, *selection));

		else

			erasedRas = TRasterP(selection->getOriginalFloatingSelection());

		TImageP erasedImage;

		if (TRasterCM32P toonzRas = (TRasterCM32P)(erasedRas))

			erasedImage = TToonzImageP(toonzRas, toonzRas->getBounds());

		else if (TRaster32P fullColorRas = (TRaster32P)(erasedRas))

			erasedImage = TRasterImageP(fullColorRas);

		TImageCache::instance()->add(m_erasedImageId, erasedImage, false);

		m_erasePoint = selection->getStartPosition();

		m_tool = TTool::getApplication()->getCurrentTool()->getTool();

	}

	~UndoDeleteSelection()

	{

		if (TImageCache::instance()->isCached(m_erasedImageId))

			TImageCache::instance()->remove(m_erasedImageId);

	}

	void undo() const

	{

		TImageP image = m_level->getFrame(m_frameId, true);

		if (!image)

			return;

		TRasterP ras = getRaster(image);

		if (!ras)

			return;

		TImageP erasedImage = TImageCache::instance()->get(m_erasedImageId, false);

		if (!erasedImage)

			return;

		TRasterP erasedRaster = getRaster(erasedImage);

		TRop::over(ras, erasedRaster, m_erasePoint);

		ToolUtils::updateSaveBox(m_level, m_frameId);

		if (!m_tool)

			return;

		m_tool->notifyImageChanged(m_frameId);

		m_tool->invalidate();

	}

	void redo() const

	{

		TImageP image = m_level->getFrame(m_frameId, true);

		TImageP erasedImage = TImageCache::instance()->get(m_erasedImageId, false);

		if (!erasedImage)

			return;

		deleteSelectionWithoutUndo(image, m_strokes);

		ToolUtils::updateSaveBox(m_level, m_frameId);

		if (!m_tool)

			return;

		m_tool->notifyImageChanged(m_frameId);

		m_tool->invalidate();

	}

	int getSize() const

	{

		return sizeof(*this);

	}

};

int UndoDeleteSelection::m_id = 0;

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

// UndoPasteSelection

//-----------------------------------------------------------------------------

class UndoPasteSelection : public TUndo

{

	RasterSelection *m_currentSelection, m_newSelection;

public:

	UndoPasteSelection(RasterSelection *currentSelection)

		: TUndo(), m_currentSelection(currentSelection), m_newSelection(*currentSelection)

	{

	}

	~UndoPasteSelection()

	{

	}

	void undo() const

	{

		m_currentSelection->setFloatingSeletion(TRasterP());

		m_currentSelection->selectNone();

		m_currentSelection->notify();

	}

	void redo() const

	{

		*m_currentSelection = m_newSelection;

		m_currentSelection->notify();

	}

	int getSize() const

	{

		return sizeof(*this);

	}

	QString getHistoryString()

	{

		return QObject::tr("Paste");

	}

};

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

// UndoPasteFloatingSelection

//-----------------------------------------------------------------------------

class UndoPasteFloatingSelection : public TUndo

{

	static int m_id;

	TXshCell m_imageCell; //!< Level/frame pair to the pasted-to image

						  //!< (seemingly cached as m_imageId)

	TPaletteP m_oldPalette, m_newPalette;

	string m_imageId, m_floatingImageId, m_undoImageId, m_oldFloatingImageId;

	vector<tstroke> m_strokes;</tstroke>

	TRectD m_selectionRect;

	TAffine m_transformation;

	TPoint m_startPos;

	bool m_isPastedSelection;

	bool m_noAntialiasing;

	TTool *m_tool;

	TFrameId m_frameId;

public:

	UndoPasteFloatingSelection(RasterSelection *currentSelection, TPalette *oldPalette, bool noAntialiasing)

		: TUndo(), m_imageCell(currentSelection->getCurrentImageCell()), m_oldPalette(oldPalette ? oldPalette->clone() : 0), m_strokes(currentSelection->getOriginalStrokes()), m_selectionRect(currentSelection->getSelectionBbox()), m_transformation(currentSelection->getTransformation()), m_isPastedSelection(currentSelection->isPastedSelection()), m_noAntialiasing(noAntialiasing), m_undoImageId(""), m_frameId(currentSelection->getFrameId())

	{

		TImageP image(currentSelection->getCurrentImage());

		if (!image)

			return;

		m_imageId = "UndoPasteImage_" + toString(m_id);

		TImageCache::instance()->add(m_imageId, image, false);

		m_floatingImageId = "UndoPasteFloatingSelection_floating_" + toString(m_id);

		TRasterP floatingRas = currentSelection->getFloatingSelection();

		TImageP floatingImage;

		if (TRasterCM32P toonzRas = (TRasterCM32P)(floatingRas))

			floatingImage = TToonzImageP(toonzRas, toonzRas->getBounds());

		else if (TRaster32P fullColorRas = (TRaster32P)(floatingRas))

			floatingImage = TRasterImageP(fullColorRas);

		else if (TRasterGR8P grRas = (TRasterGR8P)(floatingRas))

			floatingImage = TRasterImageP(grRas);

		TImageCache::instance()->add(m_floatingImageId, floatingImage, false);

		m_oldFloatingImageId = "UndoPasteFloatingSelection_oldFloating_" + toString(m_id);

		TRasterP oldFloatingRas = currentSelection->getOriginalFloatingSelection();

		TImageP olfFloatingImage;

		if (TRasterCM32P toonzRas = (TRasterCM32P)(oldFloatingRas))

			olfFloatingImage = TToonzImageP(toonzRas, toonzRas->getBounds());

		else if (TRaster32P fullColorRas = (TRaster32P)(oldFloatingRas))

			olfFloatingImage = TRasterImageP(fullColorRas);

		else if (TRasterGR8P grRas = (TRasterGR8P)(oldFloatingRas))

			olfFloatingImage = TRasterImageP(grRas);

		TImageCache::instance()->add(m_oldFloatingImageId, olfFloatingImage, false);

		TPaletteP imgPalette = image->getPalette();

		m_newPalette = imgPalette ? imgPalette->clone() : 0;

		TRasterP rasImage = getRaster(image);

		TRectD wRect = m_selectionRect.enlarge(2);

		TRect rRect = convertWorldToRaster(wRect, image);

		rRect *= rasImage->getBounds();

		if (!rRect.isEmpty()) {

			m_undoImageId = "UndoPasteFloatingSelection_undo" + toString(m_id);

			TRasterP undoRas = rasImage->extract(rRect)->clone();

			TImageP undoImage;

			if (TRasterCM32P toonzRas = (TRasterCM32P)(undoRas))

				undoImage = TToonzImageP(toonzRas, toonzRas->getBounds());

			else if (TRaster32P fullColorRas = (TRaster32P)(undoRas))

				undoImage = TRasterImageP(fullColorRas);

			else if (TRasterGR8P grRas = (TRasterGR8P)(undoRas))

				undoImage = TRasterImageP(grRas);

			TImageCache::instance()->add(m_undoImageId, undoImage, false);

		}

		m_startPos = currentSelection->getStartPosition();

		m_id++;

		m_tool = TTool::getApplication()->getCurrentTool()->getTool();

	}

	~UndoPasteFloatingSelection()

	{

		if (TImageCache::instance()->isCached(m_imageId))

			TImageCache::instance()->remove(m_imageId);

		if (TImageCache::instance()->isCached(m_floatingImageId))

			TImageCache::instance()->remove(m_floatingImageId);

		if (TImageCache::instance()->isCached(m_undoImageId))

			TImageCache::instance()->remove(m_undoImageId);

	}

	void undo() const

	{

		TImageP image = TImageCache::instance()->get(m_imageId, false);

		if (!image)

			return;

		TRasterP rasImage = getRaster(image);

		TRectD wRect = m_selectionRect.enlarge(2);

		TRect rRect = convertWorldToRaster(wRect, image);

		rRect *= rasImage->getBounds();

		if (!m_undoImageId.empty()) {

			TImageP undoImage = TImageCache::instance()->get(m_undoImageId, false);

			if (!undoImage)

				return;

			rasImage->copy(getRaster(undoImage), rRect.getP00());

		}

		TXshSimpleLevelP sl(m_imageCell.getSimpleLevel());

		const TFrameId &fid = m_imageCell.m_frameId;

		if (!m_isPastedSelection) {

			TImageP floatingImage = TImageCache::instance()->get(m_oldFloatingImageId, false);

			if (!floatingImage)

				return;

			TRasterP floatingRaster = getRaster(floatingImage);

			TRop::over(rasImage, floatingRaster, m_startPos);

		}

		ToolUtils::updateSaveBox(sl, fid);

		if (m_oldPalette)

			image->getPalette()->assign(m_oldPalette->clone());

		TTool::Application *app = TTool::getApplication();

		app->getPaletteController()->getCurrentLevelPalette()->notifyPaletteChanged();

		if (!m_tool)

			return;

		m_tool->notifyImageChanged(m_frameId);

		m_tool->invalidate();

	}

	void redo() const

	{

		TImageP image = TImageCache::instance()->get(m_imageId, false);

		TImageP floatingImage = TImageCache::instance()->get(m_floatingImageId, false);

		if (!floatingImage || !image)

			return;

		TRasterP floatingRas = getRaster(floatingImage);

		TXshSimpleLevelP sl(m_imageCell.getSimpleLevel());

		const TFrameId &fid = m_imageCell.m_frameId;

		if (!m_isPastedSelection)

			deleteSelectionWithoutUndo(image, m_strokes);

		TRasterP ras = getRaster(image);

		pasteFloatingSelectionWithoutUndo(image, floatingRas, m_transformation, m_selectionRect, m_noAntialiasing);

		ToolUtils::updateSaveBox(sl, fid);

		if (m_newPalette)

			image->getPalette()->assign(m_newPalette->clone());

		TTool::Application *app = TTool::getApplication();

		app->getPaletteController()->getCurrentLevelPalette()->notifyPaletteChanged();

		if (!m_tool)

			return;

		m_tool->notifyImageChanged(m_frameId);

		m_tool->invalidate();

	}

	int getSize() const

	{

		return sizeof(*this);

	}

	QString getHistoryString()

	{

		return QObject::tr("Paste");

	}

};

int UndoPasteFloatingSelection::m_id = 0;

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

// Next methods are used to compute intersection between selected stroke and image box

//-----------------------------------------------------------------------------

/*! Help function.*/

TSegment getSegmentByIndex(TRectD rect, int index)

{

	if (index == 0)

		return TSegment(rect.getP00(), rect.getP01());

	if (index == 1)

		return TSegment(rect.getP01(), rect.getP11());

	if (index == 2)

		return TSegment(rect.getP11(), rect.getP10());

	if (index == 3)

		return TSegment(rect.getP10(), rect.getP00());

	return TSegment();

}

//-----------------------------------------------------------------------------

/*! Help function. precPoint -> point */

bool isClockwise(TRectD bbox, int segmentIndex, TThickPoint precPoint, TThickPoint point)

{

	if (segmentIndex == 0)

		return precPoint.y > point.y;

	if (segmentIndex == 1)

		return precPoint.x > point.x;

	if (segmentIndex == 2)

		return precPoint.y < point.y;

	if (segmentIndex == 3)

		return precPoint.x < point.x;

	return true;

}

//-----------------------------------------------------------------------------

/*! Help function.*/

void addPointToVector(TThickPoint point, std::vector<tthickpoint> &points, bool insertMiddlePoint)</tthickpoint>

{

	if (insertMiddlePoint)

		points.push_back((points[points.size() - 1] + point) * 0.5);

	points.push_back(point);

}

//-----------------------------------------------------------------------------

/*! Return intersection between \b bbox and \b chuck;

    set segmentIndex to index of segment that contains intersection. */

TThickPoint getIntersectionPoint(TRectD bbox, const TThickQuadratic *chunk,

								 int &segmentIndex, bool secondChunkIntersection)

{

	TStroke stroke;

	std::vector<tthickpoint> points;</tthickpoint>

	points.push_back(chunk->getThickP0());

	points.push_back(chunk->getThickP1());

	points.push_back(chunk->getThickP2());

	stroke.reshape(&points[0], points.size());

	std::vector<doublepair> intersectionInfo;</doublepair>

	std::vector<doublepair> intersections;</doublepair>

	TSegment segment0(bbox.getP00(), bbox.getP01());

	int count0 = intersect(stroke, segment0, intersections);

	if (count0 > 0) {

		DoublePair pair;

		pair.first = intersections[0].first;

		pair.second = 0;

		intersectionInfo.push_back(pair);

		intersections.clear();

	}

	TSegment segment1(bbox.getP01(), bbox.getP11());

	int count1 = intersect(stroke, segment1, intersections);

	if (count1 > 0) {

		DoublePair pair;

		pair.first = intersections[0].first;

		pair.second = 1;

		intersectionInfo.push_back(pair);

		intersections.clear();

	}

	TSegment segment2(bbox.getP11(), bbox.getP10());

	int count2 = intersect(stroke, segment2, intersections);

	if (count2 > 0) {

		DoublePair pair;

		pair.first = intersections[0].first;

		pair.second = 2;

		intersectionInfo.push_back(pair);

		intersections.clear();

	}

	TSegment segment3(bbox.getP10(), bbox.getP00());

	int count3 = intersect(stroke, segment3, intersections);

	if (count3 > 0) {

		DoublePair pair;

		pair.first = intersections[0].first;

		pair.second = 3;

		intersectionInfo.push_back(pair);

		intersections.clear();

	}

	int infoSize = intersectionInfo.size();

	assert(infoSize <= 2);

	if (infoSize == 1) {

		segmentIndex = intersectionInfo[0].second;

		return stroke.getPoint(intersectionInfo[0].first);

	} else if (infoSize == 2) {

		double firstT = intersectionInfo[0].first;

		double secondT = intersectionInfo[1].first;

		if (!secondChunkIntersection) {

			if (firstT < secondT) {

				segmentIndex = intersectionInfo[0].second;

				return stroke.getPoint(intersectionInfo[0].first);

			} else {

				segmentIndex = intersectionInfo[1].second;

				return stroke.getPoint(intersectionInfo[1].first);

			}

		} else {

			if (firstT > secondT) {

				segmentIndex = intersectionInfo[0].second;

				return stroke.getPoint(intersectionInfo[0].first);

			} else {

				segmentIndex = intersectionInfo[1].second;

				return stroke.getPoint(intersectionInfo[1].first);

			}

		}

	}

	segmentIndex = -1;

	return TThickPoint();

}

//-----------------------------------------------------------------------------

/*! Insert \b bbox corners in \b points if \b bbox corners are contained in \b outPoints stroke. */

void insertBoxCorners(TRectD bbox, std::vector<tthickpoint> &points, std::vector<tthickpoint> outPoints,</tthickpoint></tthickpoint>

					  int currentSegmentIndex, int precSegmentIndex)

{

	if (outPoints[0] != outPoints[(int)outPoints.size() - 1])

		addPointToVector(outPoints[0], outPoints, true);

	assert((int)outPoints.size() % 2 == 1);

	TStroke *outPointsStroke = new TStroke();

	outPointsStroke->reshape(&(outPoints[0]), outPoints.size());

	TVectorImageP vi(new TVectorImage());

	vi->addStroke(outPointsStroke);

	vi->findRegions();

	assert((int)vi->getRegionCount() > 0);

	bool sameIndex = (precSegmentIndex == currentSegmentIndex);

	if (currentSegmentIndex == -1)

		return;

	int j;

	for (j = sameIndex ? 1 : 0; j < 2; j++) {

		bool clockwise = j;

		if (sameIndex)

			clockwise = isClockwise(bbox, currentSegmentIndex, outPoints[outPoints.size() - 2], outPoints[outPoints.size() - 1]);

		int segmentIndex = precSegmentIndex;

		if (sameIndex)

			segmentIndex = clockwise ? currentSegmentIndex - 1 : currentSegmentIndex + 1;

		if (segmentIndex < 0)

			segmentIndex = 3;

		if (segmentIndex > 3)

			segmentIndex = 0;

		while (segmentIndex != currentSegmentIndex) {

			if (sameIndex) //controllo anche il segmento di partenza.

			{

				segmentIndex = currentSegmentIndex;

				sameIndex = false;

			}

			TSegment s = getSegmentByIndex(bbox, segmentIndex);

			TThickPoint corner = clockwise ? s.getP0() : s.getP1();

			int i;

			for (i = 0; i < (int)vi->getRegionCount(); i++)

				if (vi->getRegion(i)->contains(corner)) {

					if ((int)points.size() % 2 == 1)

						points.push_back((points[points.size() - 1] + corner) * 0.5);

					points.push_back(corner);

				}

			segmentIndex = clockwise ? segmentIndex - 1 : segmentIndex + 1;

			if (segmentIndex < 0)

				segmentIndex = 3;

			if (segmentIndex > 3)

				segmentIndex = 0;

		}

	}

}

//-----------------------------------------------------------------------------

TStroke getStrokeByRect(TRectD r)

{

	TStroke stroke;

	if (r.isEmpty())

		return stroke;

	vector<tthickpoint> points;</tthickpoint>

	points.push_back(r.getP00());

	points.push_back((r.getP00() + r.getP01()) * 0.5);

	points.push_back(r.getP01());

	points.push_back((r.getP01() + r.getP11()) * 0.5);

	points.push_back(r.getP11());

	points.push_back((r.getP11() + r.getP10()) * 0.5);

	points.push_back(r.getP10());

	points.push_back((r.getP10() + r.getP00()) * 0.5);

	points.push_back(r.getP00());

	stroke.reshape(&(points[0]), points.size());

	stroke.setSelfLoop(true);

	return stroke;

}

//-----------------------------------------------------------------------------

TStroke getIntersectedStroke(TStroke &stroke, TRectD bbox)

{

	int cpCount = stroke.getControlPointCount();

	if (cpCount == 0)

		return stroke;

	//isFirstTime, startSegmentIndex e startOutPoints sono usati nel il caso in cui lo stroke inizia fuori dalla bbox.

	bool isFirstTime = true;

	std::vector<tthickpoint> points, outPoints, startOutPoints;</tthickpoint>

	TThickPoint precPoint = stroke.getControlPoint(0);

	bool isPrecPointInternal = bbox.contains(precPoint);

	if (isPrecPointInternal)

		points.push_back(precPoint);

	else

		outPoints.push_back(precPoint);

	int i;

	int precSegmentIndex, currentSegmentIndex, startSegmentIndex, precChunkIndex = -1;

	for (i = 1; i < stroke.getControlPointCount(); i++) {

		TThickPoint point = stroke.getControlPoint(i);

		bool isPointInternal = bbox.contains(point);

		if (isPointInternal && isPrecPointInternal)

			addPointToVector(point, points, (int)points.size() % 2 != i % 2);

		if (!isPointInternal && !isPrecPointInternal)

			addPointToVector(point, outPoints, (int)outPoints.size() > 0 && (int)outPoints.size() % 2 != i % 2);

		if (isPointInternal != isPrecPointInternal) {

			//Devo trovare l'intersezione

			int chunkIndex = (i % 2 == 0) ? (i * 0.5) - 1 : i * 0.5;

			TThickPoint p = getIntersectionPoint(bbox, stroke.getChunk(chunkIndex), currentSegmentIndex, chunkIndex == precChunkIndex);

			precChunkIndex = chunkIndex;

			addPointToVector(p, outPoints, (int)outPoints.size() % 2 == 1);

			if (!isPrecPointInternal && points.size() > 0 && outPoints.size() > 0) {

				insertBoxCorners(bbox, points, outPoints, currentSegmentIndex, precSegmentIndex);

				outPoints.clear();

			} else if (outPoints.size() > 0 && isFirstTime) {

				startSegmentIndex = currentSegmentIndex;

				startOutPoints = outPoints;

				outPoints.clear();

			}

			isFirstTime = false;

			precSegmentIndex = currentSegmentIndex;

			addPointToVector(p, points, (int)points.size() % 2 == 1);

			addPointToVector(p, outPoints, (int)outPoints.size() % 2 == 1);

		}

		if (isPointInternal && !isPrecPointInternal)

			addPointToVector(point, points, (int)points.size() % 2 != i % 2);

		if (!isPointInternal && isPrecPointInternal)

			addPointToVector(point, outPoints, (int)outPoints.size() > 0 && (int)outPoints.size() % 2 != i % 2);

		isPrecPointInternal = isPointInternal;

	}

	//Caso in cui lo stroke aveva il primo punto fuori dalla bbox

	if (!isPrecPointInternal && points.size() > 0 && outPoints.size() > 0) {

		int t;

		for (t = 0; t < (int)outPoints.size(); t++)

			addPointToVector(outPoints[t], startOutPoints, (int)startOutPoints.size() % 2 != 2);

		insertBoxCorners(bbox, points, startOutPoints, startSegmentIndex, currentSegmentIndex);

		outPoints.clear();

	}

	//Caso particolare in cui lo stroke non ha intersezione con la bbox

	if (points.size() == 0) { //Lo stroke e' completamente contenuto nella bbox

		if (bbox.contains(precPoint))

			return stroke;

		else

			return getStrokeByRect(bbox);

	}

	if (points[0] != points[(int)points.size() - 1])

		addPointToVector(points[0], points, true);

	assert((int)points.size() % 2 == 1);

	TStroke intersectedStroke;

	intersectedStroke.reshape(&(points[0]), points.size());

	intersectedStroke.setSelfLoop(true);

	return intersectedStroke;

}

} // namespace

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

// RasterSelection

//-----------------------------------------------------------------------------