#include "tcurves.h"
//#include "tpalette.h"
#include "tvectorimage.h"
#include "tvectorimageP.h"
#include "tstroke.h"
//#include "tgl.h"
#include "tvectorrenderdata.h"
#include "tmathutil.h"
//#include "tdebugmessage.h"
#include "tofflinegl.h"
//#include "tcolorstyles.h"
#include "tpaletteutil.h"
#include "tthreadmessage.h"
#include "tsimplecolorstyles.h"

#include <memory>

//=============================================================================
typedef TVectorImage::IntersectionBranch IntersectionBranch;

namespace
{

typedef std::set<int> DisabledStrokeStyles;

// uso getDisabledStrokeStyleSet() invece che accedere direttamente alla
// variabile per assicurarmi che il tutto funzioni anche quando viene
// usato PRIMA del main (per iniziativa di un costruttore di una variabile
// globale, p.es.).
// per l'idioma: cfr. Modern C++ design, Andrei Alexandrescu, Addison Wesley 2001, p.133

inline DisabledStrokeStyles &getDisabledStrokeStyleSet()
{
	static DisabledStrokeStyles disabledStokeStyles;
	return disabledStokeStyles;
}

inline bool isStrokeStyleEnabled__(int index)
{
	DisabledStrokeStyles &disabledSet = getDisabledStrokeStyleSet();
	return disabledSet.find(index) == disabledSet.end();
}

} // namespace

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

/*!
Permette di copiare effettuare delle copie delle curve
*/
/*
template <class Container> 
class StrokeArrayInsertIterator
{    
  Container& container;
  
public:
  explicit    StrokeArrayInsertIterator(Container& Line)
    :container(Line)
  {};
  
  StrokeArrayInsertIterator& operator=(const VIStroke* value )
  {
    TStroke *stroke = new TStroke(*(value->m_s));

    stroke->setId(value->m_s->getId());
    container.push_back(new VIStroke(stroke));
    return *this;
  };
  
  StrokeArrayInsertIterator&  operator*()       { return *this; }
  StrokeArrayInsertIterator&  operator++()       { return *this; }
  StrokeArrayInsertIterator   operator++(int val){ return *this; }
};
*/

//=============================================================================
/*!
TVectorImage::Imp: implementation of TVectorImage class
\relates  TVectorImage
*/

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

TVectorImage::Imp::Imp(TVectorImage *vi)
	: m_areValidRegions(false), m_notIntersectingStrokes(false), m_computeRegions(true), m_autocloseTolerance(c_newAutocloseTolerance), m_maxGroupId(1), m_maxGhostGroupId(1), m_mutex(new TThread::Mutex()), m_vi(vi), m_intersectionData(0), m_computedAlmostOnce(false), m_justLoaded(false), m_insideGroup(TGroupId()), m_minimizeEdges(true)
#ifdef NEW_REGION_FILL
	  ,
	  m_regionFinder(0)
#endif
{
#ifdef NEW_REGION_FILL
	resetRegionFinder();
#endif
	initRegionsData();
}

TVectorImage::Imp::~Imp()
{
	//delete m_regionFinder;
	deleteRegionsData();
	delete m_mutex;
}

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

TVectorImage::TVectorImage(bool loaded)
	: m_imp(new TVectorImage::Imp(this))
{
	if (loaded)
		m_imp->m_justLoaded = true;
}

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

TVectorImage::~TVectorImage()
{
}

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

int TVectorImage::isInsideGroup() const
{
	return m_imp->m_insideGroup.getDepth();
}

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

int TVectorImage::addStrokeToGroup(TStroke *stroke, int strokeIndex)
{
	if (!m_imp->m_strokes[strokeIndex]->m_groupId.isGrouped())
		return addStroke(stroke, true);
	for (int i = m_imp->m_strokes.size() - 1; i >= 0; i--)
		if (m_imp->m_strokes[i]->m_groupId == m_imp->m_strokes[strokeIndex]->m_groupId) {
			m_imp->insertStrokeAt(new VIStroke(stroke, m_imp->m_strokes[i]->m_groupId), i + 1);
			return i + 1;
		}
	assert(false);
	return -1;
}

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

int TVectorImage::addStroke(TStroke *stroke, bool discardPoints)
{

	if (discardPoints) {
		TRectD bBox = stroke->getBBox();
		if (bBox.x0 == bBox.x1 && bBox.y0 == bBox.y1) //empty stroke: discard
			return -1;
	}

	if (m_imp->m_insideGroup != TGroupId()) {
		int i;
		for (i = m_imp->m_strokes.size() - 1; i >= 0; i--)
			if (m_imp->m_insideGroup.isParentOf(m_imp->m_strokes[i]->m_groupId)) {
				m_imp->insertStrokeAt(new VIStroke(stroke, m_imp->m_strokes[i]->m_groupId), i + 1);
				return i + 1;
			}
	}

	TGroupId gid;
	if (m_imp->m_strokes.empty() || m_imp->m_strokes.back()->m_groupId.isGrouped() != 0)
		gid = TGroupId(this, true);
	else
		gid = m_imp->m_strokes.back()->m_groupId;

	m_imp->m_strokes.push_back(new VIStroke(stroke, gid));
	m_imp->m_areValidRegions = false;
	return m_imp->m_strokes.size() - 1;
}

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

void TVectorImage::moveStrokes(int fromIndex, int count, int moveBefore)
{
#ifdef _DEBUG
	m_imp->checkGroups();
#endif
	m_imp->moveStrokes(fromIndex, count, moveBefore, true);
#ifdef _DEBUG
	m_imp->checkGroups();
#endif
}

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

void TVectorImage::Imp::moveStrokes(int fromIndex, int count, int moveBefore, bool regroup)
{
	assert(fromIndex >= 0 && fromIndex < (int)m_strokes.size());
	assert(moveBefore >= 0 && moveBefore <= (int)m_strokes.size());
	assert(count > 0);

	assert(fromIndex != moveBefore);

	for (int i = 0; i < count; i++)
		if (fromIndex < moveBefore)
			moveStroke(fromIndex, moveBefore);
		else
			moveStroke(fromIndex + i, moveBefore + i);

	std::vector<int> changedStrokes;
	if (regroup)
		regroupGhosts(changedStrokes);
	if (!changedStrokes.empty())
		notifyChangedStrokes(changedStrokes, std::vector<TStroke *>(), false);
}

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

void TVectorImage::insertStrokeAt(VIStroke *vs, int strokeIndex, bool recomputeRegions)
{
	m_imp->insertStrokeAt(vs, strokeIndex, recomputeRegions);
}

/*
void TVectorImage::insertStrokeAt(TStroke *stroke, int strokeIndex, const TGroupId& id)
{
VIStroke* vs;

vs = new VIStroke(stroke, id);
  
m_imp->insertStrokeAt(vs, strokeIndex);
  
}
*/

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

/*
TRectD TVectorImage::addStroke(const std::vector<TThickPoint> &points)
{
//  era:  TStroke *stroke = makeTStroke(points);
  TStroke *stroke = TStroke::interpolate(points, 5.0);

  m_imp->m_strokes.push_back(new VIStroke( stroke) );
  m_imp->m_areValidRegions = false;
  
  return stroke->getBBox();
}
*/

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

bool isRegionWithStroke(TRegion *region, TStroke *s)
{
	for (UINT i = 0; i < region->getEdgeCount(); i++)
		if (region->getEdge(i)->m_s == s)
			return true;
	return false;
}

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

void deleteSubRegionWithStroke(TRegion *region, TStroke *s)
{
	for (int i = 0; i < (int)region->getSubregionCount(); i++) {
		deleteSubRegionWithStroke(region->getSubregion(i), s);
		if (isRegionWithStroke(region->getSubregion(i), s)) {
			TRegion *r = region->getSubregion(i);
			r->moveSubregionsTo(region);
			assert(r->getSubregionCount() == 0);
			region->deleteSubregion(i);
			delete r;
			i--;
		}
	}
}

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

TStroke *TVectorImage::removeStroke(int index, bool doComputeRegions)
{
	return m_imp->removeStroke(index, doComputeRegions);
}

TStroke *TVectorImage::Imp::removeStroke(int index, bool doComputeRegions)
{
	assert(index >= 0 && index < (int)m_strokes.size());
	QMutexLocker sl(m_mutex);

	VIStroke *stroke = m_strokes[index];

	eraseIntersection(index);

	m_strokes.erase(m_strokes.begin() + index);

	if (m_computedAlmostOnce) {
		reindexEdges(index);
		if (doComputeRegions)
			computeRegions();
	}

	return stroke->m_s;
}

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

void TVectorImage::removeStrokes(const std::vector<int> &toBeRemoved, bool deleteThem, bool recomputeRegions)
{
	m_imp->removeStrokes(toBeRemoved, deleteThem, recomputeRegions);
}

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

void TVectorImage::Imp::removeStrokes(const std::vector<int> &toBeRemoved, bool deleteThem, bool recomputeRegions)
{
	QMutexLocker sl(m_mutex);

	for (int i = toBeRemoved.size() - 1; i >= 0; i--) {
		assert(i == 0 || toBeRemoved[i - 1] < toBeRemoved[i]);
		UINT index = toBeRemoved[i];

		eraseIntersection(index);
		if (deleteThem)
			delete m_strokes[index];
		m_strokes.erase(m_strokes.begin() + index);
	}

	if (m_computedAlmostOnce && !toBeRemoved.empty()) {
		reindexEdges(toBeRemoved, false);

		if (recomputeRegions)
			computeRegions();
		else
			m_areValidRegions = false;
	}
}

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

void TVectorImage::deleteStroke(int index)
{
	TStroke *stroke = removeStroke(index);
	delete stroke;
}

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

void TVectorImage::deleteStroke(VIStroke *stroke)
{
	UINT index = 0;
	for (; index < m_imp->m_strokes.size(); index++)
		if (m_imp->m_strokes[index] == stroke) {
			deleteStroke(index);
			return;
		}
}

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

/*
void TVectorImage::validateRegionEdges(TStroke* stroke, bool invalidate)
{
if (invalidate)
  for (UINT i=0; i<getRegionCount(); i++)
    {
    TRegion *r = getRegion(i);
//  if ((*cit)->getBBox().contains(stroke->getBBox()))
    for (UINT j=0; j<r->getEdgeCount(); j++)
      {
      TEdge* edge = r->getEdge(j);
      if (edge->m_s == stroke)
        edge->m_w0 = edge->m_w1 = -1;
      }
    }
else
 for (UINT i=0; i<getRegionCount(); i++)
    {
    TRegion *r = getRegion(i);
//  if ((*cit)->getBBox().contains(stroke->getBBox()))
    for (UINT j=0; j<r->getEdgeCount(); j++)
      {
      TEdge* edge = r->getEdge(j);
      if (edge->m_w0==-1)
        {
        int index;
        double t, dummy;
        edge->m_s->getNearestChunk(edge->m_p0, t, index, dummy);
        edge->m_w0 = getWfromChunkAndT(edge->m_s, index, t);
        edge->m_s->getNearestChunk(edge->m_p1, t, index, dummy);
        edge->m_w1 = getWfromChunkAndT(edge->m_s, index, t);
        }
      }
    }


}
*/
//-----------------------------------------------------------------------------

UINT TVectorImage::getStrokeCount() const
{
	return m_imp->m_strokes.size();
}

//-----------------------------------------------------------------------------
/*
void  TVectorImage::addSeed(const TPointD& p, const TPixel& color)
{
m_imp->m_seeds.push_back(TFillSeed(color, p, NULL));
}
*/
//-----------------------------------------------------------------------------

UINT TVectorImage::getRegionCount() const
{
	//  assert( m_imp->m_areValidRegions || m_imp->m_regions.empty());
	return m_imp->m_regions.size();
}

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

TRegion *TVectorImage::getRegion(UINT index) const
{
	assert(index < m_imp->m_regions.size());
	//  assert( m_imp->m_areValidRegions );
	return m_imp->m_regions[index];
}

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

TRegion *TVectorImage::getRegion(TRegionId regId) const
{
	int index = getStrokeIndexById(regId.m_strokeId);

	assert(m_imp->m_areValidRegions);

	TRegion *reg = m_imp->getRegion(regId, index);
	//assert( reg );
	return reg;
}

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

TRegion *TVectorImage::Imp::getRegion(TRegionId regId, int index) const
{
	assert(index != -1);
	if (index == -1)
		return 0;

	assert(index < (int)m_strokes.size());
	if (index >= (int)m_strokes.size())
		return 0;

	std::list<TEdge *> &edgeList = m_strokes[index]->m_edgeList;

	std::list<TEdge *>::iterator endList = edgeList.end();
	double w0;
	double w1;
	for (std::list<TEdge *>::iterator it = edgeList.begin(); it != endList; ++it) {
		w0 = (*it)->m_w0;
		w1 = (*it)->m_w1;

		if (w0 < w1) {
			if (w0 < regId.m_midW && regId.m_midW < w1 && regId.m_direction)
				return (*it)->m_r;
		} else {
			if (w1 < regId.m_midW && regId.m_midW < w0 && !regId.m_direction)
				return (*it)->m_r;
		}
	}

#ifdef _DEBUG
	TPointD cp1 = m_strokes[index]->m_s->getControlPoint(0);
	TPointD cp2 = m_strokes[index]->m_s->getControlPoint(m_strokes[index]->m_s->getControlPointCount() - 1);
#endif

	return 0;
}

/*
TRegion* TVectorImage::getRegion(TRegionId regId) const
{
  int index = getStrokeIndexById(regId.m_strokeId);
  assert(index!=-1);
  if( index == -1 )
    return 0;

  assert( index < (int)m_imp->m_strokes.size() );
  if( index >= (int)m_imp->m_strokes.size() )
    return 0;

  std::list<TEdge*> &edgeList = m_imp->m_strokes[index]->m_edgeList;

  std::list<TEdge*>::iterator endList = edgeList.end();
  double w0;
  double w1;
  for(list<TEdge*>::iterator it= edgeList.begin(); it!=endList; ++it)
  {
    w0 = (*it)->m_w0;
    w1 = (*it)->m_w1;

    if(w0<w1)
    {
      if( w0 < regId.m_midW && regId.m_midW < w1 && regId.m_direction )
        return (*it)->m_r;
    }
    else
    {
      if( w1 < regId.m_midW && regId.m_midW < w0 && !regId.m_direction )
        return (*it)->m_r;
    }
  }

  return 0;   
}
*/
//-----------------------------------------------------------------------------

void TVectorImage::setEdgeColors(int strokeIndex, int leftColorIndex, int rightColorIndex)
{
	std::list<TEdge *> &ll = m_imp->m_strokes[strokeIndex]->m_edgeList;

	std::list<TEdge *>::const_iterator l = ll.begin();
	std::list<TEdge *>::const_iterator l_e = ll.end();
	for (; l != l_e; ++l) {
		//double w0 = (*l)->m_w0, w1 = (*l)->m_w1;
		if ((*l)->m_w0 > (*l)->m_w1) {
			if (leftColorIndex != -1)
				(*l)->m_styleId = leftColorIndex;
			else if (rightColorIndex != -1)
				(*l)->m_styleId = rightColorIndex;
		} else {
			if (rightColorIndex != -1)
				(*l)->m_styleId = rightColorIndex;
			else if (leftColorIndex != -1)
				(*l)->m_styleId = leftColorIndex;
		}
	}
}

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

TStroke *TVectorImage::getStroke(UINT index) const
{
	assert(index < m_imp->m_strokes.size());
	return m_imp->m_strokes[index]->m_s;
}

VIStroke *TVectorImage::getVIStroke(UINT index) const
{
	assert(index < m_imp->m_strokes.size());
	return m_imp->m_strokes[index];
}

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

VIStroke *TVectorImage::getStrokeById(int id) const
{
	int n = m_imp->m_strokes.size();
	for (int i = 0; i < n; i++)
		if (m_imp->m_strokes[i]->m_s->getId() == id)
			return m_imp->m_strokes[i];
	return 0;
}

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

int TVectorImage::getStrokeIndexById(int id) const
{
	int n = m_imp->m_strokes.size();

	for (int i = 0; i < n; i++)
		if (m_imp->m_strokes[i]->m_s->getId() == id)
			return i;

	return -1;
}

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

int TVectorImage::getStrokeIndex(TStroke *stroke) const
{
	int n = m_imp->m_strokes.size();

	for (int i = 0; i < n; i++)
		if (m_imp->m_strokes[i]->m_s == stroke)
			return i;

	return -1;
}

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

TRectD TVectorImage::getBBox() const
{
	UINT strokeCount = m_imp->m_strokes.size();
	if (strokeCount == 0)
		return TRectD();

	TPalette *plt = getPalette();
	TRectD bbox;

	for (UINT i = 0; i < strokeCount; ++i) {
		TRectD r = m_imp->m_strokes[i]->m_s->getBBox();
		TColorStyle *style = 0;
		if (plt)
			style = plt->getStyle(m_imp->m_strokes[i]->m_s->getStyle());
		if (dynamic_cast<TRasterImagePatternStrokeStyle *>(style) ||
			dynamic_cast<TVectorImagePatternStrokeStyle *>(style)) //con i pattern style, il render a volte taglia sulla bbox dello stroke....
																   //aumento la bbox della meta' delle sue dimensioni:pezzaccia.
			r = r.enlarge(std::max(r.getLx() * 0.25, r.getLy() * 0.25));
		bbox = ((i == 0) ? r : bbox + r);
	}

	return bbox;
}

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

bool TVectorImage::getNearestStroke(
	const TPointD &p,
	double &outW,
	UINT &strokeIndex,
	double &dist2,
	bool onlyInCurrentGroup) const
{
	dist2 = (std::numeric_limits<double>::max)();
	strokeIndex = getStrokeCount();
	outW = -1;

	double
		tempdis2,
		tempPar;

	for (int i = 0; i < (int)m_imp->m_strokes.size(); ++i) {
		if (onlyInCurrentGroup && !inCurrentGroup(i))
			continue;
		TStroke *s = m_imp->m_strokes[i]->m_s;
		tempPar = s->getW(p);

		tempdis2 = tdistance2(TThickPoint(p, 0), s->getThickPoint(tempPar));

		if (tempdis2 < dist2) {
			outW = tempPar;
			dist2 = tempdis2;
			strokeIndex = i;
		}
	}

	return dist2 < (std::numeric_limits<double>::max)();
}

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

#if defined(LINUX) || defined(MACOSX)
void TVectorImage::render(const TVectorRenderData &rd, TRaster32P &ras)
{
	//hardRenderVectorImage(rd,ras,this);
}
#endif

//-----------------------------------------------------------------------------
//#include "timage_io.h"

TRaster32P TVectorImage::render(bool onlyStrokes)
{
	TRect bBox = convert(getBBox());
	if (bBox.isEmpty())
		return (TRaster32P)0;

	std::auto_ptr<TOfflineGL> offlineGlContext(new TOfflineGL(bBox.getSize()));
	offlineGlContext->clear(TPixel32(0, 0, 0, 0));
	offlineGlContext->makeCurrent();
	TVectorRenderData rd(TTranslation(-convert(bBox.getP00())), TRect(bBox.getSize()), getPalette(), 0, true, true);
	rd.m_drawRegions = !onlyStrokes;
	offlineGlContext->draw(this, rd, false);

	return offlineGlContext->getRaster()->clone();

	//hardRenderVectorImage(rd,ras,this);
}

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

TRegion *TVectorImage::getRegion(const TPointD &p)
{
#ifndef NEW_REGION_FILL
	if (!isComputedRegionAlmostOnce())
		return 0;

	if (!m_imp->m_areValidRegions)
		m_imp->computeRegions();
#endif

	return m_imp->getRegion(p);
}

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

TRegion *TVectorImage::Imp::getRegion(const TPointD &p)
{
	int strokeIndex = (int)m_strokes.size() - 1;

	while (strokeIndex >= 0) {
		for (UINT regionIndex = 0; regionIndex < m_regions.size(); regionIndex++)
			if (areDifferentGroup(strokeIndex, false, regionIndex, true) == -1 && m_regions[regionIndex]->contains(p))
				return m_regions[regionIndex]->getRegion(p);
		int curr = strokeIndex;
		while (strokeIndex >= 0 && areDifferentGroup(curr, false, strokeIndex, false) == -1)
			strokeIndex--;
	}

	return 0;
}

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

int TVectorImage::fillStrokes(const TPointD &p, int styleId)
{
	UINT index;
	double outW, dist2;

	if (getNearestStroke(p, outW, index, dist2, true)) {
		double thick = getStroke(index)->getThickPoint(outW).thick * 1.25;
		if (thick < 0.5)
			thick = 0.5;

		if (dist2 > thick * thick)
			return -1;
		assert(index >= 0 && index < m_imp->m_strokes.size());
		int ret = m_imp->m_strokes[index]->m_s->getStyle();
		m_imp->m_strokes[index]->m_s->setStyle(styleId);
		return ret;
	}

	return -1;
}

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

#ifdef NEW_REGION_FILL

void TVectorImage::resetRegionFinder()
{
	m_imp->resetRegionFinder();
}
#else
//------------------------------------------------------------------

int TVectorImage::fill(const TPointD &p, int newStyleId, bool onlyEmpty)
{

	TRegion *r = getRegion(p);
	if (onlyEmpty && r && r->getStyle() != 0)
		return -1;

	if (!m_imp->m_areValidRegions)
		m_imp->computeRegions();
	return m_imp->fill(p, newStyleId);
}
#endif

//-----------------------------------------------------------------------------
/*
void TVectorImage::autoFill(int styleId)
{
m_imp->autoFill(styleId, true);
}

void TVectorImage::Imp::autoFill(int styleId, bool oddLevel)
{
if (!m_areValidRegions)
  computeRegions(); 
for (UINT i = 0; i<m_regions.size(); i++)
  {
  if (oddLevel)
    m_regions[i]->setStyle(styleId);
  m_regions[i]->autoFill(styleId, !oddLevel);
  }
}
*/
//-----------------------------------------------------------------------------
/*
void TRegion::autoFill(int styleId, bool oddLevel)
{
for (UINT i = 0; i<getSubregionCount(); i++)
  {
  TRegion* r = getSubregion(i);
  if (oddLevel)
    r->setStyle(styleId);
  r->autoFill(styleId, !oddLevel);
  }

}
*/
//-----------------------------------------------------------------------------

int TVectorImage::Imp::fill(const TPointD &p, int styleId)
{
	int strokeIndex = (int)m_strokes.size() - 1;

	while (strokeIndex >= 0) {
		if (!inCurrentGroup(strokeIndex)) {
			strokeIndex--;
			continue;
		}
		for (UINT regionIndex = 0; regionIndex < m_regions.size(); regionIndex++)
			if (areDifferentGroup(strokeIndex, false, regionIndex, true) == -1 && m_regions[regionIndex]->contains(p))
				return m_regions[regionIndex]->fill(p, styleId);
		int curr = strokeIndex;
		while (strokeIndex >= 0 && areDifferentGroup(curr, false, strokeIndex, false) == -1)
			strokeIndex--;
	}

	return -1;
}

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

bool TVectorImage::selectFill(const TRectD &selArea, TStroke *s, int newStyleId, bool onlyUnfilled, bool fillAreas, bool fillLines)
{
	if (!m_imp->m_areValidRegions)
		m_imp->computeRegions();
	return m_imp->selectFill(selArea, s, newStyleId, onlyUnfilled, fillAreas, fillLines);
}

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

bool TVectorImage::Imp::selectFill(const TRectD &selArea, TStroke *s, int newStyleId, bool onlyUnfilled, bool fillAreas, bool fillLines)
{
	bool hitSome = false;

	if (s) {
		TVectorImage aux;
		aux.addStroke(s);
		aux.findRegions();
		for (UINT j = 0; j < aux.getRegionCount(); j++) {
			TRegion *r0 = aux.getRegion(j);
			if (fillAreas)
				for (UINT i = 0; i < m_regions.size(); i++) {
					TRegion *r1 = m_regions[i];

					if (m_insideGroup != TGroupId() && !m_insideGroup.isParentOf(m_strokes[r1->getEdge(0)->m_index]->m_groupId))
						continue;

					if ((!onlyUnfilled || r1->getStyle() == 0) &&
						r0->contains(*r1)) {
						r1->setStyle(newStyleId);
						hitSome = true;
					}
				}
			if (fillLines)
				for (UINT i = 0; i < m_strokes.size(); i++) {
					if (!inCurrentGroup(i))
						continue;

					TStroke *s1 = m_strokes[i]->m_s;
					if ((!onlyUnfilled || s1->getStyle() == 0) &&
						r0->contains(*s1)) {
						s1->setStyle(newStyleId);
						hitSome = true;
					}
				}
		}
		aux.removeStroke(0);
		return hitSome;
	}

	// rect fill

	if (fillAreas)
#ifndef NEW_REGION_FILL
		for (UINT i = 0; i < m_regions.size(); i++) {
			int index, j = 0;

			do
				index = m_regions[i]->getEdge(j++)->m_index;
			while (index < 0 && j < (int)m_regions[i]->getEdgeCount());
			//if index<0, means that the region is purely of autoclose strokes!
			if (m_insideGroup != TGroupId() && index >= 0 && !m_insideGroup.isParentOf(m_strokes[index]->m_groupId))
				continue;
			if (!onlyUnfilled || m_regions[i]->getStyle() == 0)
				hitSome |= m_regions[i]->selectFill(selArea, newStyleId);
		}
#else

		findRegions(selArea);

	for (UINT i = 0; i < m_regions.size(); i++) {
		if (m_insideGroup != TGroupId() && !m_insideGroup.isParentOf(m_strokes[m_regions[i]->getEdge(0)->m_index]->m_groupId))
			continue;
		if (!onlyUnfilled || m_regions[i]->getStyle() == 0)
			hitSome |= m_regions[i]->selectFill(selArea, newStyleId);
	}
#endif

	if (fillLines)
		for (UINT i = 0; i < m_strokes.size(); i++) {
			if (!inCurrentGroup(i))
				continue;

			TStroke *s = m_strokes[i]->m_s;

			if ((!onlyUnfilled || s->getStyle() == 0) && selArea.contains(s->getBBox())) {
				s->setStyle(newStyleId);
				hitSome = true;
			}
		}
	return hitSome;
}

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

/*
void  TVectorImageImp::seedFill()
{
  std::vector<TFillSeed>::iterator it;
  TRegion*r;

  TFillStyleP app =NULL;

  for (it=m_seeds.begin(); it!=m_seeds.end(); )
    if ((r=fill(it->m_p, new TColorStyle(it->m_fillStyle.getPointer()) ))!=NULL)        
    {
      it->m_r = r;
      it = m_seeds.erase(it);  // i seed provengono da immagini vecchie. non servono piu'.
    }
  m_areValidRegions=true;
}
*/
//-----------------------------------------------------------------------------
/*
void  TVectorImage::seedFill()
{
  m_imp->seedFill();
 
}
*/
//-----------------------------------------------------------------------------

void TVectorImage::notifyChangedStrokes(const std::vector<int> &strokeIndexArray, const std::vector<TStroke *> &oldStrokeArray, bool areFlipped)
{
	std::vector<TStroke *> aux;

	/*
if (oldStrokeArray.empty())
  {
	for (int i=0; i<(int)strokeIndexArray.size(); i++)
	  {
		TStroke *s = getStroke(strokeIndexArray[i]);
	  aux.push_back(s);
		}
  m_imp->notifyChangedStrokes(strokeIndexArray, aux, areFlipped);
	}
else*/
	m_imp->notifyChangedStrokes(strokeIndexArray, oldStrokeArray, areFlipped);
}

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

void TVectorImage::notifyChangedStrokes(int strokeIndexArray, TStroke *oldStroke, bool isFlipped)
{
	std::vector<int> app(1);
	app[0] = strokeIndexArray;

	std::vector<TStroke *> oldStrokeArray(1);
	oldStrokeArray[0] = oldStroke ? oldStroke : getStroke(strokeIndexArray);
	m_imp->notifyChangedStrokes(app, oldStrokeArray, isFlipped);
}

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

//ofstream of("C:\\temp\\butta.txt");

void transferColors(const std::list<TEdge *> &oldList, const std::list<TEdge *> &newList, bool isStrokeChanged, bool isFlipped, bool overwriteColor)
{
	if (newList.empty() || oldList.empty())
		return;

	std::list<TEdge *>::const_iterator it;
// unused variable
#if 0 
list<TEdge*>::const_iterator it1;
#endif
	double totLenght;
	if (isStrokeChanged)
		totLenght = newList.front()->m_s->getLength();
	for (it = newList.begin(); it != newList.end(); ++it) {
		int newStyle = -1; // ErrorStyle;
// unused variable
#if 0 
  int styleId = (*it)->m_styleId;
#endif
		if (!overwriteColor && (*it)->m_styleId != 0)
			continue;
		bool reversed;
		double deltaMax = 0.005;
		double l0, l1;
		if ((*it)->m_w0 > (*it)->m_w1) {
			reversed = !isFlipped;
			if (isStrokeChanged) {
				l0 = (*it)->m_s->getLength((*it)->m_w1) / totLenght;
				l1 = (*it)->m_s->getLength((*it)->m_w0) / totLenght;
			} else {
				l0 = (*it)->m_w1;
				l1 = (*it)->m_w0;
			}
		} else {
			reversed = isFlipped;
			if (isStrokeChanged) {
				l0 = (*it)->m_s->getLength((*it)->m_w0) / totLenght;
				l1 = (*it)->m_s->getLength((*it)->m_w1) / totLenght;
			} else {
				l0 = (*it)->m_w0;
				l1 = (*it)->m_w1;
			}
			//w0 = (*it)->m_w0;
			//w1 = (*it)->m_w1;
		}

		std::list<TEdge *>::const_iterator it1 = oldList.begin();
		for (; it1 != oldList.end(); ++it1) {
// unused variable
#if 0
      TEdge*e = *it1;
#endif
			if (/*(*it1)->m_styleId==0 ||*/
				(reversed && (*it1)->m_w0 < (*it1)->m_w1) ||
				(!reversed && (*it1)->m_w0 > (*it1)->m_w1))
				continue;
			double _l0, _l1;
			if (isStrokeChanged) {
				double totLenght1 = (*it1)->m_s->getLength();

				_l0 = (*it1)->m_s->getLength(std::min((*it1)->m_w0, (*it1)->m_w1)) / totLenght1;
				_l1 = (*it1)->m_s->getLength(std::max((*it1)->m_w0, (*it1)->m_w1)) / totLenght1;
			} else {
				_l0 = std::min((*it1)->m_w0, (*it1)->m_w1);
				_l1 = std::max((*it1)->m_w0, (*it1)->m_w1);
			}
			double delta = std::min(l1, _l1) - std::max(l0, _l0);
			if (delta > deltaMax) {
				deltaMax = delta;
				newStyle = (*it1)->m_styleId;
			}
		}
		if (newStyle >= 0) // !=ErrorStyle)
		{
			if ((*it)->m_r)
				(*it)->m_r->setStyle(newStyle);
			else
				(*it)->m_styleId = newStyle;
		}
	}
}

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

void TVectorImage::transferStrokeColors(TVectorImageP sourceImage,
										int sourceStroke,
										TVectorImageP destinationImage,
										int destinationStroke)
{
	std::list<TEdge *> *sourceList = &(sourceImage->m_imp->m_strokes[sourceStroke]->m_edgeList);
	std::list<TEdge *> *destinationList = &(destinationImage->m_imp->m_strokes[destinationStroke]->m_edgeList);
	transferColors(*sourceList, *destinationList, true, false, false);
}

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

bool TVectorImage::Imp::areWholeGroups(const std::vector<int> &indexes) const
{
	UINT i, j;
	for (i = 0; i < indexes.size(); i++) {
		if (m_strokes[indexes[i]]->m_isNewForFill)
			return false;
		if (!m_strokes[indexes[i]]->m_groupId.isGrouped() != 0)
			return false;
		for (j = 0; j < m_strokes.size(); j++) {
			int ret = areDifferentGroup(indexes[i], false, j, false);
			if (ret == -1 || ret >= 1 && find(indexes.begin(), indexes.end(), j) == indexes.end())
				return false;
		}
	}
	return true;
}

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

//-------------------------------------------------------------------
void invalidateRegionPropAndBBox(TRegion *reg);

void TVectorImage::Imp::notifyChangedStrokes(const std::vector<int> &strokeIndexArray, const std::vector<TStroke *> &oldStrokeArray, bool areFlipped)
{

#ifdef _DEBUG
	checkIntersections();
#endif

	assert(oldStrokeArray.empty() || strokeIndexArray.size() == oldStrokeArray.size());

	if (!m_computedAlmostOnce && !m_notIntersectingStrokes)
		return;

	typedef std::list<TEdge *> EdgeList;
	std::vector<EdgeList> oldEdgeListArray(strokeIndexArray.size());
	int i;

	//se si sono trasformati  interi gruppi (senza deformare le stroke) non c'e' bisogno di ricalcolare le regioni!
	if (oldStrokeArray.empty() && areWholeGroups(strokeIndexArray)) {
		m_areValidRegions = true;
		for (i = 0; i < (int)m_regions.size(); i++)
			invalidateRegionPropAndBBox(m_regions[i]);
		return;
	}

	QMutexLocker sl(m_mutex);
	for (i = 0; i < (int)strokeIndexArray.size(); i++) //ATTENZIONE! non si puo' fare eraseIntersection in questo stesso ciclo
	{
		VIStroke *s = m_strokes[strokeIndexArray[i]];
		//if (s->m_s->isSelfLoop())
		//  assert(s->m_edgeList.size()<=1);

		std::list<TEdge *>::iterator it = s->m_edgeList.begin();
		for (; it != s->m_edgeList.end(); it++) {
			TEdge *e = new TEdge(**it, false);
			if (!oldStrokeArray.empty())
				e->m_s = oldStrokeArray[i];
			oldEdgeListArray[i].push_back(e); //bisogna allocare nuovo edge, perche'la eraseIntersection poi lo cancella....
			if ((*it)->m_toBeDeleted)
				delete *it;
		}
		s->m_edgeList.clear();
	}

	for (i = 0; i < (int)strokeIndexArray.size(); i++) {
		eraseIntersection(strokeIndexArray[i]);
		if (!m_notIntersectingStrokes)
			m_strokes[strokeIndexArray[i]]->m_isNewForFill = true;
	}

	computeRegions(); // m_imp->m_strokes, m_imp->m_regions);

	for (i = 0; i < (int)strokeIndexArray.size(); i++) {
		transferColors(oldEdgeListArray[i], m_strokes[strokeIndexArray[i]]->m_edgeList, true, areFlipped, false);
		clearPointerContainer(oldEdgeListArray[i]);
	}

#ifdef _DEBUG
	checkIntersections();
#endif
}

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

void TVectorImage::findRegions(bool fromSwf)
{
	//for (int i=0; i<(int)m_imp->m_strokes.size(); i++)
	//  {
	//  m_imp->eraseIntersection(i);
	//	  m_imp->m_strokes[i]->m_isNewForFill=true;
	//  }

	if (m_imp->m_areValidRegions)
		return;

	//m_imp->m_regions.clear();

	// compute regions...
	m_imp->computeRegions(); // m_imp->m_strokes, m_imp->m_regions);
}

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

void TVectorImage::putRegion(TRegion *region)
{
	m_imp->m_regions.push_back(region);
}

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

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

void TVectorImage::Imp::cloneRegions(TVectorImage::Imp &out, bool doComputeRegions)
{
	std::unique_ptr<IntersectionBranch[]> v;
	UINT size = getFillData(v);
	out.setFillData(v, size, doComputeRegions);
}

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

TVectorImageP TVectorImage::clone() const
{
	return TVectorImageP(cloneImage());
}

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

TImage *TVectorImage::cloneImage() const
{
	TVectorImage *out = new TVectorImage;

	out->m_imp->m_autocloseTolerance = m_imp->m_autocloseTolerance;
	out->m_imp->m_maxGroupId = m_imp->m_maxGroupId;
	out->m_imp->m_maxGhostGroupId = m_imp->m_maxGhostGroupId;

	for (int i = 0; i < (int)m_imp->m_strokes.size(); i++) {
		out->m_imp->m_strokes.push_back(new VIStroke(*(m_imp->m_strokes[i])));
		out->m_imp->m_strokes.back()->m_s->setId(m_imp->m_strokes[i]->m_s->getId());
	}

	m_imp->cloneRegions(*out->m_imp);

	out->setPalette(getPalette());
	out->m_imp->m_computedAlmostOnce = m_imp->m_computedAlmostOnce;
	out->m_imp->m_justLoaded = m_imp->m_justLoaded;

	return out;
}

//-----------------------------------------------------------------------------
/*
TVectorImageP mergeAndClear(TVectorImageP v1, TVectorImageP v2 )
{
  TVectorImageP out = new TVectorImage;
  
  std::vector<VIStroke*>::iterator it_b =  v1->m_imp->m_strokes.begin();
  std::vector<VIStroke*>::iterator it_e =  v1->m_imp->m_strokes.end();
  
  std::copy( it_b, it_e, std::back_inserter( out->m_imp->m_strokes ) );
  
  it_b =  v2->m_imp->m_strokes.begin();
  it_e =  v2->m_imp->m_strokes.end();
  
  std::copy( it_b, it_e, std::back_inserter( out->m_imp->m_strokes ) );
  
  v1->m_imp->m_regions.clear();
  v1->m_imp->m_strokes.clear();
  v2->m_imp->m_regions.clear();
  v2->m_imp->m_strokes.clear();
  
  out->m_imp->m_areValidRegions = false;
  return out;
}
*/

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

VIStroke::VIStroke(const VIStroke &s, bool sameId)
	: m_isPoint(s.m_isPoint), m_isNewForFill(s.m_isNewForFill), m_groupId(s.m_groupId)
{
	m_s = new TStroke(*s.m_s);
	std::list<TEdge *>::const_iterator it = s.m_edgeList.begin(), it_e = s.m_edgeList.end();
	for (; it != it_e; ++it) {
		m_edgeList.push_back(new TEdge(**it, true));
		m_edgeList.back()->m_s = m_s;
	}
	if (sameId)
		m_s->setId(s.m_s->getId());
}

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

void TVectorImage::mergeImage(const TVectorImageP &img, const TAffine &affine, bool sameStrokeId)
{
	QMutexLocker sl(m_imp->m_mutex);

#ifdef _DEBUG
	checkIntersections();
#endif

	TPalette *tarPlt = getPalette();
	TPalette *srcPlt = img->getPalette();

	assert(tarPlt);
	assert(tarPlt->getPageCount() > 0);

	// merge della palette
	std::map<int, int> styleTable;
	std::set<int> usedStyles;
	img->getUsedStyles(usedStyles);

	// gmt, 16/10/07. Quando si copia e incolla un path su uno stroke succede
	// che la palette dell'immagine sorgente sia vuota. Non mi sembra sbagliato
	// mettere comunque un test qui
	if (srcPlt)
		mergePalette(tarPlt, styleTable, srcPlt, usedStyles);

	mergeImage(img, affine, styleTable, sameStrokeId);
}

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

void TVectorImage::mergeImage(const TVectorImageP &img, const TAffine &affine, const std::map<int, int> &styleTable, bool sameStrokeId)
{
	int imageSize = img->getStrokeCount();
	if (imageSize == 0)
		return;
	QMutexLocker sl(m_imp->m_mutex);

	m_imp->m_computedAlmostOnce |= img->m_imp->m_computedAlmostOnce;

	std::vector<int> changedStrokeArray(imageSize);

	img->m_imp->reindexGroups(*m_imp);

	int i;
	int insertAt = 0;

	if (m_imp->m_insideGroup != TGroupId()) //if is inside a group, new image is put in that group.
	{
		TGroupId groupId;
		for (i = m_imp->m_strokes.size() - 1; i >= 0; i--)
			if (m_imp->m_insideGroup.isParentOf(m_imp->m_strokes[i]->m_groupId)) {
				insertAt = i + 1;
				groupId = m_imp->m_strokes[i]->m_groupId;
				break;
			}
		if (insertAt != 0)
			for (i = 0; i < (int)img->m_imp->m_strokes.size(); i++)
				if (!img->m_imp->m_strokes[i]->m_groupId.isGrouped())
					img->m_imp->m_strokes[i]->m_groupId = groupId;
				else
					img->m_imp->m_strokes[i]->m_groupId = TGroupId(groupId, img->m_imp->m_strokes[i]->m_groupId);

	}

	//si fondono l'ultimo gruppo ghost della vecchia a e il primo della nuova

	else if (!m_imp->m_strokes.empty() && m_imp->m_strokes.back()->m_groupId.isGrouped(true) != 0 && img->m_imp->m_strokes[0]->m_groupId.isGrouped(true) != 0) {
		TGroupId idNew = m_imp->m_strokes.back()->m_groupId, idOld = img->m_imp->m_strokes[0]->m_groupId;
		for (i = 0; i < (int)img->m_imp->m_strokes.size() && img->m_imp->m_strokes[i]->m_groupId == idOld; i++)
			img->m_imp->m_strokes[i]->m_groupId = idNew;
	}

	// merge dell'immagine
	std::map<int, int>::const_iterator styleTableIt;
	int oldSize = getStrokeCount();

	for (i = 0; i < imageSize; i++) {
		VIStroke *srcStroke = img->m_imp->m_strokes[i];
		VIStroke *tarStroke = new VIStroke(*srcStroke, sameStrokeId);

		int styleId;
		// cambio i colori delle regioni
		std::list<TEdge *>::const_iterator it = tarStroke->m_edgeList.begin(), it_e = tarStroke->m_edgeList.end();
		for (; it != it_e; ++it) {
			int styleId = (*it)->m_styleId;
			styleTableIt = styleTable.find(styleId);
			assert(styleTableIt != styleTable.end());
			if (styleTableIt != styleTable.end())
				(*it)->m_styleId = styleTableIt->second;
		}

		tarStroke->m_s->transform(affine, true);
		int strokeId = srcStroke->m_s->getId();
		if (getStrokeById(strokeId) == 0)
			tarStroke->m_s->setId(strokeId);

		// cambio i colori dello stroke
		styleId = srcStroke->m_s->getStyle();
		styleTableIt = styleTable.find(styleId);
		assert(styleTableIt != styleTable.end());
		if (styleTableIt != styleTable.end())
			tarStroke->m_s->setStyle(styleTableIt->second);
		if (insertAt == 0) {
			m_imp->m_strokes.push_back(tarStroke);
			changedStrokeArray[i] = oldSize + i;
		} else {
			std::vector<VIStroke *>::iterator it = m_imp->m_strokes.begin();
			advance(it, insertAt + i);
			m_imp->m_strokes.insert(it, tarStroke);
			changedStrokeArray[i] = insertAt + i;
		}
	}
	if (insertAt > 0) {
		//for (i=changedStrokeArray.back()+1; i<m_imp->m_strokes.size(); i++)
		//  changedStrokeArray.push_back(i);
		m_imp->reindexEdges(changedStrokeArray, true);
	}

	notifyChangedStrokes(changedStrokeArray, std::vector<TStroke *>(), false);

#ifdef _DEBUG
	checkIntersections();
#endif
}

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

void TVectorImage::Imp::reindexGroups(TVectorImage::Imp &img)
{
	UINT i, j;
	int newMax = img.m_maxGroupId;
	int newMaxGhost = img.m_maxGhostGroupId;
	for (i = 0; i < m_strokes.size(); i++) {
		VIStroke *s = m_strokes[i];
		if (s->m_groupId.m_id.empty())
			continue;
		if (s->m_groupId.m_id[0] > 0)
			for (j = 0; j < s->m_groupId.m_id.size(); j++) {
				s->m_groupId.m_id[j] += img.m_maxGroupId;
				newMax = std::max(newMax, s->m_groupId.m_id[j]);
			}
		else
			for (j = 0; j < s->m_groupId.m_id.size(); j++) {
				s->m_groupId.m_id[j] -= img.m_maxGhostGroupId;
				newMaxGhost = std::max(newMaxGhost, -s->m_groupId.m_id[j]);
			}
	}
	m_maxGroupId = img.m_maxGroupId = newMax;
	m_maxGhostGroupId = img.m_maxGhostGroupId = newMaxGhost;
}

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

void TVectorImage::mergeImage(const std::vector<const TVectorImage *> &images)
{
	UINT oldSize = getStrokeCount();
	std::vector<int> changedStrokeArray;
	const TVectorImage *img;
	int index;

	if (m_imp->m_insideGroup != TGroupId()) {
		for (index = m_imp->m_strokes.size() - 1; index > -1; index--)
			if (m_imp->m_insideGroup.isParentOf(m_imp->m_strokes[index]->m_groupId))
				break;
		assert(index > -1);
	} else
		index = getStrokeCount() - 1;

	for (UINT j = 0; j < images.size(); ++j) {
		img = images[j];
		if (img->getStrokeCount() == 0)
			continue;

		img->m_imp->reindexGroups(*m_imp);

		int i = 0;
		/*if (!m_imp->m_strokes.empty() && m_imp->m_strokes[index-1]->m_groupId.isGrouped(true)!=0 &&
      img->m_imp->m_strokes[0]->m_groupId.isGrouped(true)!=0)
    {
    assert(false);
    TGroupId idNew = m_imp->m_strokes[index]->m_groupId, idOld = img->m_imp->m_strokes[0]->m_groupId;
    for  (;i<(int)img->m_imp->m_strokes.size() && img->m_imp->m_strokes[i]->m_groupId==idOld; i++) 
      img->m_imp->m_strokes[i]->m_groupId==idNew;
    }*/

		int strokeCount = img->getStrokeCount();
		m_imp->m_computedAlmostOnce |= img->m_imp->m_computedAlmostOnce;
		for (i = 0; i < strokeCount; i++) {
			VIStroke *srcStroke = img->m_imp->m_strokes[i];
			VIStroke *tarStroke = new VIStroke(*srcStroke);
			int strokeId = srcStroke->m_s->getId();
			if (getStrokeById(strokeId) == 0)
				tarStroke->m_s->setId(strokeId);

			index++;
			if (m_imp->m_insideGroup == TGroupId())
				m_imp->m_strokes.push_back(tarStroke);
			else //if we are inside a group, the images must become part of that group
			{
				tarStroke->m_groupId = TGroupId(m_imp->m_insideGroup, tarStroke->m_groupId);
				m_imp->insertStrokeAt(tarStroke, index);
			}

			changedStrokeArray.push_back(index);
		}
	}

	notifyChangedStrokes(changedStrokeArray, std::vector<TStroke *>(), false);
}
//-------------------------------------------------------------------

void TVectorImage::recomputeRegionsIfNeeded()
{
	if (!m_imp->m_justLoaded)
		return;

	m_imp->m_justLoaded = false;

	std::vector<int> v(m_imp->m_strokes.size());
	int i;
	for (i = 0; i < (int)m_imp->m_strokes.size(); i++)
		v[i] = i;

	m_imp->notifyChangedStrokes(v, std::vector<TStroke *>(), false);
}

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

void TVectorImage::eraseStyleIds(const std::vector<int> styleIds)
{
	int j;
	for (j = 0; j < (int)styleIds.size(); j++) {
		int styleId = styleIds[j];

		int strokeCount = getStrokeCount();
		int i;
		for (i = strokeCount - 1; i >= 0; i--) {
			TStroke *stroke = getStroke(i);
			if (stroke && stroke->getStyle() == styleId)
				removeStroke(i);
		}
		int regionCount = getRegionCount();
		for (i = 0; i < regionCount; i++) {
			TRegion *region = getRegion(i);
			if (!region || region->getStyle() != styleId)
				continue;
			TPointD p;
			if (region->getInternalPoint(p))
				fill(p, 0);
		}
	}
}

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

void TVectorImage::insertImage(const TVectorImageP &img, const std::vector<int> &dstIndices)
{
	UINT i;
	UINT imageSize = img->getStrokeCount();
	assert(dstIndices.size() == imageSize);

	//img->m_imp->reindexGroups(*m_imp);
	std::vector<int> changedStrokeArray(imageSize);

	std::vector<VIStroke *>::iterator it = m_imp->m_strokes.begin();

	for (i = 0; i < imageSize; i++) {
		assert(i == 0 || dstIndices[i] > dstIndices[i - 1]);

		VIStroke *srcStroke = img->m_imp->m_strokes[i];
		VIStroke *tarStroke = new VIStroke(*srcStroke);
		int strokeId = srcStroke->m_s->getId();
		if (getStrokeById(strokeId) == 0)
			tarStroke->m_s->setId(strokeId);
		advance(it, (i == 0) ? dstIndices[i] : dstIndices[i] - dstIndices[i - 1]);

		it = m_imp->m_strokes.insert(it, tarStroke);

		changedStrokeArray[i] = dstIndices[i];
	}
	m_imp->reindexEdges(changedStrokeArray, true);

	notifyChangedStrokes(changedStrokeArray, std::vector<TStroke *>(), false);
	//m_imp->computeRegions();
}

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

void TVectorImage::enableRegionComputing(bool enabled, bool notIntersectingStrokes)
{
	m_imp->m_computeRegions = enabled;
	m_imp->m_notIntersectingStrokes = notIntersectingStrokes;
}

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

void TVectorImage::enableMinimizeEdges(bool enabled)
{
	m_imp->m_minimizeEdges = enabled;
}

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

TVectorImageP TVectorImage::splitImage(const std::vector<int> &indices, bool removeFlag)
{
	TVectorImageP out = new TVectorImage;
	out->m_imp->m_maxGroupId = m_imp->m_maxGroupId;
	out->m_imp->m_maxGhostGroupId = m_imp->m_maxGhostGroupId;

	std::vector<int> toBeRemoved;

	TPalette *vp = getPalette();
	if (vp)
		out->setPalette(vp->clone());

	for (UINT i = 0; i < indices.size(); ++i) {
		VIStroke *ref = m_imp->m_strokes[indices[i]];
		assert(ref);
		VIStroke *vs = new VIStroke(*ref);
		vs->m_isNewForFill = true;
		out->m_imp->m_strokes.push_back(vs);
	}

	if (removeFlag)
		removeStrokes(indices, true, true);
	out->m_imp->m_areValidRegions = false;
	out->m_imp->m_computedAlmostOnce = m_imp->m_computedAlmostOnce;
	return out;
}

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

TVectorImageP TVectorImage::splitSelected(bool removeFlag)
{
	TVectorImageP out = new TVectorImage;
	std::vector<int> toBeRemoved;

	for (UINT i = 0; i < getStrokeCount(); ++i) {
		VIStroke *ref = m_imp->m_strokes[i];
		assert(ref);
		if (ref->m_s->getFlag(TStroke::c_selected_flag)) {
			VIStroke *stroke = new VIStroke(*ref);
			out->m_imp->m_strokes.push_back(stroke);
			if (removeFlag) {
				toBeRemoved.push_back(i);
				//  	  removeStroke(i);
				//			delete ref;
				//  	  i--;
			}
		}
	}
	removeStrokes(toBeRemoved, true, true);
	out->m_imp->m_areValidRegions = false;
	return out;
}

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

void TVectorImage::validateRegions(bool state)
{
	m_imp->m_areValidRegions = state;
}

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

/*
void TVectorImage::invalidateBBox()
{
  for(UINT i=0; i<getRegionCount(); i++) 
    getRegion(i)->invalidateBBox();
}
*/
//-----------------------------------------------------------------------------

void TVectorImage::setFillData(std::unique_ptr<IntersectionBranch[]> const& v, UINT branchCount, bool doComputeRegions)
{
	m_imp->setFillData(v, branchCount, doComputeRegions);
}

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

UINT TVectorImage::getFillData(std::unique_ptr<IntersectionBranch[]>& v)
{
	return m_imp->getFillData(v);
}

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

void TVectorImage::enableStrokeStyle(int index, bool enable)
{
	DisabledStrokeStyles &disabledSet = getDisabledStrokeStyleSet();
	if (enable)
		disabledSet.erase(index);
	else
		disabledSet.insert(index);
}

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

bool TVectorImage::isStrokeStyleEnabled(int index)
{
	return isStrokeStyleEnabled__(index);
}

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

void TVectorImage::getUsedStyles(std::set<int> &styles) const
{
	UINT strokeCount = getStrokeCount();
	UINT i = 0;
	for (; i < strokeCount; ++i) {
		VIStroke *srcStroke = m_imp->m_strokes[i];
		int styleId = srcStroke->m_s->getStyle();
		if (styleId != 0)
			styles.insert(styleId);
		std::list<TEdge *>::const_iterator it = srcStroke->m_edgeList.begin();
		for (; it != srcStroke->m_edgeList.end(); ++it) {
			styleId = (*it)->m_styleId;
			if (styleId != 0)
				styles.insert(styleId);
		}
	}
}

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

inline double recomputeW1(double oldW, const TStroke &oldStroke, const TStroke &newStroke, double startW)
{
	double oldLenght = oldStroke.getLength();
	double newLenght = newStroke.getLength();

	assert(startW <= oldW);
	assert(newLenght < oldLenght);

	double s = oldStroke.getLength(startW, oldW);
	assert(s <= newLenght || areAlmostEqual(s, newLenght, 1e-5));

	return newStroke.getParameterAtLength(s);
}

//-----------------------------------------------------------------------------
inline double recomputeW2(double oldW, const TStroke &oldStroke, const TStroke &newStroke, double length)
{
	double s = oldStroke.getLength(oldW);
	return newStroke.getParameterAtLength(length + s);
}

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

inline double recomputeW(double oldW, const TStroke &oldStroke, const TStroke &newStroke, bool isAtBegin)
{
	double oldLenght = oldStroke.getLength();
	double newLenght = newStroke.getLength();

	assert(newLenght < oldLenght);
	double s = oldStroke.getLength(oldW) - ((isAtBegin) ? 0 : oldLenght - newLenght);
	assert(s <= newLenght || areAlmostEqual(s, newLenght, 1e-5));

	return newStroke.getParameterAtLength(s);
}

//-----------------------------------------------------------------------------
#ifdef _DEBUG
void TVectorImage::checkIntersections()
{
	m_imp->checkIntersections();
}
#endif

/*
void TVectorImage::reassignStyles()
{
  set<int> styles;
  UINT  strokeCount = getStrokeCount();
  UINT i=0;
  
  for( ; i< strokeCount; ++i)
    {
     int styleId = getStroke(i)->getStyle();
     if(styleId != 0) styles.insert(styleId);
    }
  UINT regionCount = getRegionCount();
  for( i = 0; i< regionCount; ++i)
    {
     int styleId = getRegion(i)->getStyle();
     if(styleId != 0) styles.insert(styleId);
    }

  map<int, int> conversionTable;
  for(set<int>::iterator it = styles.begin(); it != styles.end(); ++it)
    {
     int styleId = *it;
     conversionTable[styleId] = styleId + 13;
    }

  for( i = 0; i< strokeCount; ++i)
    {
     TStroke *stroke = getStroke(i);
     int styleId = stroke->getStyle();
     if(styleId != 0)
       {
        map<int, int>::iterator it = conversionTable.find(styleId);
        if(it != conversionTable.end()) 
          stroke->setStyle(it->second);
       }
    }

  for( i = 0; i< regionCount; ++i)
    {
     TRegion *region = getRegion(i);
     int styleId = region->getStyle();
     if(styleId != 0)
       {
        map<int, int>::iterator it = conversionTable.find(styleId);
        if(it != conversionTable.end()) 
          region->setStyle(it->second);
       }
    }
}

*/

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

bool TVectorImage::isComputedRegionAlmostOnce() const
{
	return m_imp->m_computedAlmostOnce;
}

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

void TVectorImage::splitStroke(int strokeIndex, const std::vector<DoublePair> &sortedWRanges)
{
	m_imp->splitStroke(strokeIndex, sortedWRanges);
}

void TVectorImage::Imp::splitStroke(int strokeIndex, const std::vector<DoublePair> &sortedWRanges)
{
	int i;
	VIStroke *subV = 0;

	if (strokeIndex >= (int)m_strokes.size() || sortedWRanges.empty())
		return;

	VIStroke *vs = m_strokes[strokeIndex];
	TGroupId groupId = vs->m_groupId;

	//se e' un self loop, alla fine non lo sara', e deve stare insieme
	//alle stroke non loopate. sposto lo stroke se serve
	/*
  {
if (vs->m_s->isSelfLoop())  
  int up = strokeIndex+1;
  while (up<(int)m_strokes.size() && m_strokes[up]->m_s->isSelfLoop())
    up++;
  int dn = strokeIndex-1;
  while (dn>=0 && m_strokes[dn]->m_s->isSelfLoop())
    dn--;
  if ((up == m_strokes.size() || up!=strokeIndex+1) && (dn<0 || dn!=strokeIndex-1))
    {
    if (up>=(int)m_strokes.size())
      {
      assert(dn>=0);
      moveStroke(strokeIndex, dn+1);
      strokeIndex = dn+1;
      }
    else 
      {
      moveStroke(strokeIndex, up-1);
      strokeIndex = up-1;
      }
    }
  }
*/
	assert(vs == m_strokes[strokeIndex]);

	bool toBeJoined = (vs->m_s->isSelfLoop() && sortedWRanges.front().first == 0.0 && sortedWRanges.back().second == 1.0);

	int styleId = vs->m_s->getStyle();
	TStroke::OutlineOptions oOptions(vs->m_s->outlineOptions());

	m_regions.clear();

	std::list<TEdge *> origEdgeList; //metto al pizzo la edge std::list della stroke, perche' la erase intersection ne fara' scempio
	std::list<TEdge *>::iterator it = vs->m_edgeList.begin(), it_e = vs->m_edgeList.end();
	for (; it != it_e; ++it)
		origEdgeList.push_back(new TEdge(**it, false));

	removeStroke(strokeIndex, false);

	std::vector<std::list<TEdge *>> edgeList(sortedWRanges.size());
	strokeIndex--;

	int wSize = (int)sortedWRanges.size();

	for (i = 0; i < wSize; i++) {

		assert(sortedWRanges[i].first < sortedWRanges[i].second);
		assert(i == wSize - 1 || sortedWRanges[i].second <= sortedWRanges[i + 1].first);
		assert(sortedWRanges[i].first >= 0 && sortedWRanges[i].first <= 1);
		assert(sortedWRanges[i].second >= 0 && sortedWRanges[i].second <= 1);

		subV = new VIStroke(new TStroke(), groupId);
		TStroke s, dummy;

		if (areAlmostEqual(sortedWRanges[i].first, 0, 1e-4))
			s = *vs->m_s;
		else
			vs->m_s->split(sortedWRanges[i].first, dummy, s);

		double lenAtW0 = vs->m_s->getLength(sortedWRanges[i].first);
		double lenAtW1 = vs->m_s->getLength(sortedWRanges[i].second);
		double newW1 = s.getParameterAtLength(lenAtW1 - lenAtW0);

		if (areAlmostEqual(newW1, 1.0, 1e-4))
			*(subV->m_s) = s;
		else
			s.split(newW1, *(subV->m_s), dummy);

		strokeIndex++;
		/*assert(m_strokes[strokeIndex]->m_edgeList.empty());
  assert(m_strokes[strokeIndex-wSize+1]->m_edgeList.empty());*/

		std::list<TEdge *>::const_iterator it = origEdgeList.begin(), it_e = origEdgeList.end();
		for (; it != it_e; ++it) {
			double wMin = std::min((*it)->m_w0, (*it)->m_w1);
			double wMax = std::max((*it)->m_w0, (*it)->m_w1);

			if (wMin >= sortedWRanges[i].second || wMax <= sortedWRanges[i].first)
				continue;

			TEdge *e = new TEdge(**it, false);
			if (wMin < sortedWRanges[i].first)
				wMin = 0.0;
			else
				wMin = recomputeW1(wMin, *(vs->m_s), *(subV->m_s), sortedWRanges[i].first);

			if (wMax > sortedWRanges[i].second)
				wMax = 1.0;
			else
				wMax = recomputeW1(wMax, *(vs->m_s), *(subV->m_s), sortedWRanges[i].first);

			if (e->m_w0 < e->m_w1)
				e->m_w0 = wMin, e->m_w1 = wMax;
			else
				e->m_w1 = wMin, e->m_w0 = wMax;
			e->m_r = 0;
			e->m_s = subV->m_s;
			e->m_index = strokeIndex;
			edgeList[i].push_back(e);
		}
		subV->m_edgeList.clear();
		insertStrokeAt(subV, strokeIndex);
		subV->m_s->setStyle(styleId);
		subV->m_s->outlineOptions() = oOptions;
	}

	clearPointerContainer(origEdgeList);

	if (toBeJoined) //la stroke e' un loop, quindi i due choncketti iniziali e finali vanno joinati
	{
		VIStroke *s0 = m_strokes[strokeIndex];
		VIStroke *s1 = m_strokes[strokeIndex - wSize + 1];
		std::list<TEdge *> &l0 = edgeList.back();
		std::list<TEdge *> &l1 = edgeList.front();

		//assert(s0->m_edgeList.empty());
		//assert(s1->m_edgeList.empty());
		removeStroke(strokeIndex - wSize + 1, false);

		strokeIndex--;
		removeStroke(strokeIndex, false);

		VIStroke *s = new VIStroke(joinStrokes(s0->m_s, s1->m_s), groupId);
		insertStrokeAt(s, strokeIndex);

		std::list<TEdge *>::iterator it = l0.begin(), it_e = l0.end();
		for (; it != it_e; ++it) {
			(*it)->m_s = s->m_s;
			(*it)->m_index = strokeIndex;
			(*it)->m_w0 = recomputeW2((*it)->m_w0, *(s0->m_s), *(s->m_s), 0);
			(*it)->m_w1 = recomputeW2((*it)->m_w1, *(s0->m_s), *(s->m_s), 0);
		}
		it = l1.begin();
		double length = s0->m_s->getLength();
		while (it != l1.end()) {
			(*it)->m_s = s->m_s;
			(*it)->m_index = strokeIndex;
			(*it)->m_w0 = recomputeW2((*it)->m_w0, *(s1->m_s), *(s->m_s), length);
			(*it)->m_w1 = recomputeW2((*it)->m_w1, *(s1->m_s), *(s->m_s), length);
			l0.push_back(*it);
			it = l1.erase(it);
		}
		assert(l1.empty());
		edgeList.erase(edgeList.begin());

		std::vector<DoublePair> appSortedWRanges;

		wSize--;

		delete s0;
		delete s1;
	}

	//checkIntersections();

	//double len  = e->m_s->getLength();
	//if (recomputeRegions)

	if (m_computedAlmostOnce) {
		computeRegions();
		assert((int)edgeList.size() == wSize);
		assert((int)m_strokes.size() > strokeIndex);

		for (i = 0; i < wSize; i++)
			transferColors(edgeList[i], m_strokes[strokeIndex - wSize + i + 1]->m_edgeList, false, false, false);
	}

	for (i = 0; i < wSize; i++)
		clearPointerContainer(edgeList[i]);

	delete vs;
}

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

void computeEdgeList(TStroke *newS, const std::list<TEdge *> &edgeList1, bool join1AtBegin,
					 const std::list<TEdge *> &edgeList2, bool join2AtBegin, std::list<TEdge *> &edgeList)
{
	std::list<TEdge *>::const_iterator it;

	if (!edgeList1.empty()) {
		TStroke *s1 = edgeList1.front()->m_s;
		double lenght1 = s1->getLength();
		;

		for (it = edgeList1.begin(); it != edgeList1.end(); ++it) {
			double l0 = s1->getLength((*it)->m_w0), l1 = s1->getLength((*it)->m_w1);
			if (join1AtBegin)
				l0 = lenght1 - l0, l1 = lenght1 - l1;

			TEdge *e = new TEdge();
			e->m_toBeDeleted = true;
			e->m_index = -1;
			e->m_s = newS;
			e->m_styleId = (*it)->m_styleId;
			e->m_w0 = newS->getParameterAtLength(l0);
			e->m_w1 = newS->getParameterAtLength(l1);
			edgeList.push_back(e);
		}
	}

	if (!edgeList2.empty()) {
		TStroke *s2 = edgeList2.front()->m_s;
		double offset = newS->getLength(newS->getW(s2->getPoint(0.0)));
		double lenght2 = s2->getLength();
		for (it = edgeList2.begin(); it != edgeList2.end(); ++it) {
			double l0 = s2->getLength((*it)->m_w0), l1 = s2->getLength((*it)->m_w1);
			if (!join2AtBegin)
				l0 = lenght2 - l0, l1 = lenght2 - l1;

			TEdge *e = new TEdge();
			e->m_toBeDeleted = true;
			e->m_index = -1;
			e->m_s = newS;
			e->m_styleId = (*it)->m_styleId;
			e->m_w0 = newS->getParameterAtLength(offset + l0);
			e->m_w1 = newS->getParameterAtLength(offset + l1);
			edgeList.push_back(e);
		}
	}
}

//-----------------------------------------------------------------------------
#ifdef _DEBUG

//#include "tpalette.h"
#include "tcolorstyles.h"

void printEdges(std::ofstream &os, char *str, TPalette *plt, const std::list<TEdge *> &edges)
{
	std::list<TEdge *>::const_iterator it;

	os << str << std::endl;

	for (it = edges.begin(); it != edges.end(); ++it) {
		TColorStyle *style = plt->getStyle((*it)->m_styleId);
		TPixel32 color = style->getMainColor();
		os << "w0-w1:(" << (*it)->m_w0 << "-->" << (*it)->m_w1 << ")" << std::endl;
		os << "color=(" << color.r << "," << color.g << "," << color.b << ")" << std::endl;
	}
	os << std::endl
	   << std::endl
	   << std::endl;
}
#else
#define printEdges

#endif
//-----------------------------------------------------------------------------

#ifdef _DEBUG
void TVectorImage::Imp::printStrokes(std::ofstream &os)
{
	for (int i = 0; i < (int)m_strokes.size(); i++) {
		os << "*****stroke #" << i << " *****";
		m_strokes[i]->m_s->print(os);
	}
}

#endif

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

TStroke *TVectorImage::removeEndpoints(int strokeIndex)
{
	return m_imp->removeEndpoints(strokeIndex);
}

void TVectorImage::restoreEndpoints(int index, TStroke *oldStroke)
{
	m_imp->restoreEndpoints(index, oldStroke);
}

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

VIStroke *TVectorImage::Imp::extendStrokeSmoothly(int index, const TThickPoint &pos, int cpIndex)
{
	TStroke *stroke = m_strokes[index]->m_s;
	TGroupId groupId = m_strokes[index]->m_groupId;

	int cpCount = stroke->getControlPointCount();
	int styleId = stroke->getStyle();
	const TThickQuadratic *q = stroke->getChunk(cpIndex == 0 ? 0 : stroke->getChunkCount() - 1);

	double len = q->getLength();
	double w = exp(-len * 0.01);
	TThickPoint m = q->getThickP1();

	TThickPoint p1 = (cpIndex == 0 ? q->getThickP0() : q->getThickP2()) * (1 - w) + m * w;
	TThickPoint middleP = (p1 + pos) * 0.5;

	double angle = fabs(cross(normalize(m - middleP), normalize(pos - middleP)));
	if (angle < 0.05)
		middleP = (m + pos) * 0.5;

	stroke->setControlPoint(cpIndex, middleP);
	if (isAlmostZero(len)) {
		if (cpIndex == 0)
			stroke->setControlPoint(1, middleP * 0.1 + stroke->getControlPoint(2) * 0.9);
		else
			stroke->setControlPoint(cpCount - 2, middleP * 0.1 + stroke->getControlPoint(cpCount - 3) * 0.9);
	}

	std::vector<TThickPoint> points(cpCount);
	for (int i = 0; i < cpCount - 1; i++)
		points[i] = stroke->getControlPoint((cpIndex == 0) ? cpCount - i - 1 : i);
	points[cpCount - 1] = pos;

	TStroke *newStroke = new TStroke(points);
	newStroke->setStyle(styleId);
	newStroke->outlineOptions() = stroke->outlineOptions();
	std::list<TEdge *> oldEdgeList, emptyList;
	computeEdgeList(newStroke, m_strokes[index]->m_edgeList, cpIndex == 0,
					emptyList, 0, oldEdgeList);

	std::vector<int> toBeDeleted;
	toBeDeleted.push_back(index);
	removeStrokes(toBeDeleted, true, false);

	insertStrokeAt(new VIStroke(newStroke, groupId), index, false);
	computeRegions();
	transferColors(oldEdgeList, m_strokes[index]->m_edgeList, true, false, true);

	return m_strokes[index];
}

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

VIStroke *TVectorImage::Imp::extendStroke(int index, const TThickPoint &p, int cpIndex)
{
	TGroupId groupId = m_strokes[index]->m_groupId;

	TStroke *stroke = m_strokes[index]->m_s;

	TStroke *ret;
	int cpCount = stroke->getControlPointCount();
	int count = 0;
	std::vector<TThickPoint> points(cpCount + 2);
	int i, incr = (cpIndex == 0) ? -1 : 1;
	for (i = ((cpIndex == 0) ? cpCount - 1 : 0); i != cpIndex + incr; i += incr)
		points[count++] = stroke->getControlPoint(i);
	TThickPoint tp(p, points[count - 1].thick);
	points[count++] = 0.5 * (stroke->getControlPoint(cpIndex) + tp);
	points[count++] = tp;

	TStroke *newStroke = new TStroke(points);
	newStroke->setStyle(stroke->getStyle());
	newStroke->outlineOptions() = stroke->outlineOptions();
	ret = newStroke;
	std::list<TEdge *> oldEdgeList, emptyList;

	if (m_computedAlmostOnce)
		computeEdgeList(newStroke, m_strokes[index]->m_edgeList, cpIndex == 0, emptyList, false, oldEdgeList);

	std::vector<int> toBeDeleted;
	toBeDeleted.push_back(index);
	removeStrokes(toBeDeleted, true, false);

	//removeStroke(index, false);

	insertStrokeAt(new VIStroke(newStroke, groupId), index, false);

	if (m_computedAlmostOnce) {
		computeRegions();
		transferColors(oldEdgeList, m_strokes[index]->m_edgeList, true, false, true);
	}
	return m_strokes[index];
}

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

VIStroke *TVectorImage::Imp::joinStroke(int index1, int index2, int cpIndex1, int cpIndex2)
{
	assert(m_strokes[index1]->m_groupId == m_strokes[index2]->m_groupId);

	TGroupId groupId = m_strokes[index1]->m_groupId;

	TStroke *stroke1 = m_strokes[index1]->m_s;
	TStroke *stroke2 = m_strokes[index2]->m_s;
	//TStroke* ret;
	int cpCount1 = stroke1->getControlPointCount();
	int cpCount2 = stroke2->getControlPointCount();
	int styleId = stroke1->getStyle();

	int count = 0;
	std::vector<TThickPoint> points(cpCount1 + ((index1 != index2) ? cpCount2 : 1) + 1);
	int i, incr = (cpIndex1 == 0) ? -1 : 1;
	for (i = ((cpIndex1 == 0) ? cpCount1 - 1 : 0); i != cpIndex1 + incr; i += incr)
		points[count++] = stroke1->getControlPoint(i);
	points[count++] = 0.5 * (stroke1->getControlPoint(cpIndex1) + stroke2->getControlPoint(cpIndex2));
	if (index1 != index2) {
		incr = (cpIndex2 == 0) ? 1 : -1;
		for (i = cpIndex2; i != ((cpIndex2 == 0) ? cpCount2 - 1 : 0) + incr; i += incr)
			points[count++] = stroke2->getControlPoint(i);
	} else
		points[count++] = stroke2->getControlPoint(cpIndex2);

	TStroke *newStroke = new TStroke(points);
	newStroke->setStyle(styleId);
	newStroke->outlineOptions() = stroke1->outlineOptions();
	//ret = newStroke;
	if (index1 == index2)
		newStroke->setSelfLoop();
	std::list<TEdge *> oldEdgeList, emptyList;

	computeEdgeList(newStroke, m_strokes[index1]->m_edgeList, cpIndex1 == 0,
					(index1 != index2) ? m_strokes[index2]->m_edgeList : emptyList,
					cpIndex2 == 0, oldEdgeList);

	std::vector<int> toBeDeleted;
	toBeDeleted.push_back(index1);
	if (index1 != index2)
		toBeDeleted.push_back(index2);
	removeStrokes(toBeDeleted, true, false);

	insertStrokeAt(new VIStroke(newStroke, groupId), index1, false);
	computeRegions();
	transferColors(oldEdgeList, m_strokes[index1]->m_edgeList, true, false, true);
	return m_strokes[index1];
}

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

VIStroke *TVectorImage::Imp::joinStrokeSmoothly(int index1, int index2, int cpIndex1, int cpIndex2)
{
	assert(m_strokes[index1]->m_groupId == m_strokes[index2]->m_groupId);

	TGroupId groupId = m_strokes[index1]->m_groupId;

	TStroke *stroke1 = m_strokes[index1]->m_s;
	TStroke *stroke2 = m_strokes[index2]->m_s;
	TStroke *ret;
	int cpCount1 = stroke1->getControlPointCount();
	int cpCount2 = stroke2->getControlPointCount();
	int styleId = stroke1->getStyle();

	int qCount1 = stroke1->getChunkCount();
	int qCount2 = stroke2->getChunkCount();
	const TThickQuadratic *q1 = stroke1->getChunk(cpIndex1 == 0 ? 0 : qCount1 - 1);
	const TThickQuadratic *q2 = stroke2->getChunk(cpIndex2 == 0 ? 0 : qCount2 - 1);

	double len1 = q1->getLength();
	assert(len1 >= 0);
	if (len1 <= 0)
		len1 = 0;
	double w1 = exp(-len1 * 0.01);

	double len2 = q2->getLength();
	assert(len2 >= 0);
	if (len2 <= 0)
		len2 = 0;
	double w2 = exp(-len2 * 0.01);

	TThickPoint extreme1 = cpIndex1 == 0 ? q1->getThickP0() : q1->getThickP2();
	TThickPoint extreme2 = cpIndex2 == 0 ? q2->getThickP0() : q2->getThickP2();

	TThickPoint m1 = q1->getThickP1();
	TThickPoint m2 = q2->getThickP1();

	TThickPoint p1 = extreme1 * (1 - w1) + m1 * w1;
	TThickPoint p2 = extreme2 * (1 - w2) + m2 * w2;

	TThickPoint middleP = (p1 + p2) * 0.5;

	double angle = fabs(cross(normalize(m1 - middleP), normalize(m2 - middleP)));
	if (angle < 0.05)
		middleP = (m1 + m2) * 0.5;

	stroke1->setControlPoint(cpIndex1, middleP);
	if (isAlmostZero(len1)) {
		if (cpIndex1 == 0)
			stroke1->setControlPoint(1, middleP * 0.1 + stroke1->getControlPoint(2) * 0.9);
		else
			stroke1->setControlPoint(cpCount1 - 2, middleP * 0.1 + stroke1->getControlPoint(cpCount1 - 3) * 0.9);
	}

	stroke2->setControlPoint(cpIndex2, middleP);
	if (isAlmostZero(len2)) {
		if (cpIndex2 == 0)
			stroke2->setControlPoint(1, middleP * 0.1 + stroke2->getControlPoint(2) * 0.9);
		else
			stroke2->setControlPoint(cpCount2 - 2, middleP * 0.1 + stroke2->getControlPoint(cpCount2 - 3) * 0.9);
	}

	if (stroke1 == stroke2) {
		std::list<TEdge *> oldEdgeList, emptyList;
		computeEdgeList(stroke1, m_strokes[index1]->m_edgeList, cpIndex1 == 0,
						emptyList, false, oldEdgeList);
		eraseIntersection(index1);
		m_strokes[index1]->m_isNewForFill = true;
		stroke1->setSelfLoop();
		computeRegions();
		transferColors(oldEdgeList, m_strokes[index1]->m_edgeList, true, false, true);
		return m_strokes[index1];
		//nundo->m_newStroke=new TStroke(*stroke1);
		//nundo->m_newStrokeId=stroke1->getId();
	}

	std::vector<TThickPoint> points;
	points.reserve(cpCount1 + cpCount2 - 1);

	int incr = (cpIndex1) ? 1 : -1;
	int stop = cpIndex1;

	int i = cpCount1 - 1 - cpIndex1;
	for (; i != stop; i += incr)
		points.push_back(stroke1->getControlPoint(i));

	incr = (cpIndex2) ? -1 : 1;
	stop = cpCount2 - 1 - cpIndex2;

	for (i = cpIndex2; i != stop; i += incr)
		points.push_back(stroke2->getControlPoint(i));

	points.push_back(stroke2->getControlPoint(stop));

	TStroke *newStroke = new TStroke(points);
	newStroke->setStyle(styleId);
	newStroke->outlineOptions() = stroke1->outlineOptions();
	ret = newStroke;
	//nundo->m_newStroke=new TStroke(*newStroke);
	//nundo->m_newStrokeId=newStroke->getId();
	std::list<TEdge *> oldEdgeList;
	//ofstream os("c:\\temp\\edges.txt");

	//printEdges(os, "****edgelist1", getPalette(), m_imp->m_strokes[index1]->m_edgeList);
	//printEdges(os, "****edgelist2", getPalette(), m_imp->m_strokes[index2]->m_edgeList);

	computeEdgeList(newStroke, m_strokes[index1]->m_edgeList, cpIndex1 == 0,
					m_strokes[index2]->m_edgeList, cpIndex2 == 0, oldEdgeList);
	//printEdges(os, "****edgelist", getPalette(), oldEdgeList);

	std::vector<int> toBeDeleted;
	toBeDeleted.push_back(index1);
	toBeDeleted.push_back(index2);
	removeStrokes(toBeDeleted, true, false);

	insertStrokeAt(new VIStroke(newStroke, groupId), index1);
	computeRegions();
	transferColors(oldEdgeList, m_strokes[index1]->m_edgeList, true, false, true);

	return m_strokes[index1];

	//  TUndoManager::manager()->add(nundo);
}

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

VIStroke *TVectorImage::joinStroke(int index1, int index2, int cpIndex1, int cpIndex2, bool isSmooth)
{
	int finalStyle = -1;

	if (index1 > index2) {
		finalStyle = getStroke(index1)->getStyle();
		tswap(index1, index2);
		tswap(cpIndex1, cpIndex2);
	}
	/*
  if (index1==index2) //selfLoop!
    {
    if (index1>0 && index1<(int)getStrokeCount()-1 && 
        !getStroke(index1-1)->isSelfLoop() &&
        !getStroke(index1+1)->isSelfLoop())
      {
      for (UINT i = index1+2; i<getStrokeCount() && !getStroke(i)->isSelfLoop(); i++)
        ;
      moveStroke(index1, i-1);
      index1 = index2 = i-1;
      }
    }
  */
	VIStroke *ret;
	if (isSmooth)
		ret = m_imp->joinStrokeSmoothly(index1, index2, cpIndex1, cpIndex2);
	else
		ret = m_imp->joinStroke(index1, index2, cpIndex1, cpIndex2);

	if (finalStyle != -1)
		getStroke(index1)->setStyle(finalStyle);
	return ret;
}

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

VIStroke *TVectorImage::extendStroke(int index, const TThickPoint &p, int cpIndex, bool isSmooth)
{

	if (isSmooth)
		return m_imp->extendStrokeSmoothly(index, p, cpIndex);
	else
		return m_imp->extendStroke(index, p, cpIndex);
}

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

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

TInputStreamInterface &TInputStreamInterface::operator>>(TPixel32 &pixel)
{
	return *this >> pixel.r >> pixel.g >> pixel.b >> pixel.m;
}

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

TOutputStreamInterface &TOutputStreamInterface::operator<<(const TPixel32 &pixel)
{
	return *this << pixel.r << pixel.g << pixel.b << pixel.m;
}

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

void TVectorImage::setAutocloseTolerance(double val)
{
	m_imp->m_autocloseTolerance = val;
}

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

double TVectorImage::getAutocloseTolerance() const
{
	return m_imp->m_autocloseTolerance;
}

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

TThread::Mutex *TVectorImage::getMutex() const
{
	return m_imp->m_mutex;
}

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

void TVectorImage::areaFill(TStroke *stroke, int index, bool m_onlyUnfilled)
{
	TVectorImage v;
	v.addStroke(stroke);
	v.findRegions();

	for (UINT i = 0; i < v.getRegionCount(); i++)
		for (UINT j = 0; j < getRegionCount(); j++) {
			if (m_imp->m_insideGroup != TGroupId() && !m_imp->m_insideGroup.isParentOf(m_imp->m_strokes[getRegion(j)->getEdge(0)->m_index]->m_groupId))
				continue;

			if (v.getRegion(i)->contains(*getRegion(j)))
				getRegion(j)->setStyle(index);
		}

	v.removeStroke(0);
}

VIStroke *cloneVIStroke(VIStroke *vs)
{
	return new VIStroke(*vs);
}

void deleteVIStroke(VIStroke *vs)
{
	delete vs;
	vs = 0;
}

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

bool TVectorImage::sameSubGroup(int index0, int index1) const
{
	if (index0 < 0 || index1 < 0)
		return 0;
	return m_imp->m_strokes[index0]->m_groupId.getCommonParentDepth(m_imp->m_strokes[index1]->m_groupId) > m_imp->m_insideGroup.getDepth();
}

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

int TVectorImage::getCommonGroupDepth(int index0, int index1) const
{
	if (index0 < 0 || index1 < 0)
		return 0;
	return m_imp->m_strokes[index0]->m_groupId.getCommonParentDepth(m_imp->m_strokes[index1]->m_groupId);
}

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

int TVectorImage::ungroup(int fromIndex)
{
	m_imp->m_insideGroup = TGroupId();

	assert(m_imp->m_strokes[fromIndex]->m_groupId.isGrouped() != 0);
	std::vector<int> changedStrokes;

	int toIndex = fromIndex + 1;

	while (toIndex < (int)m_imp->m_strokes.size() && m_imp->m_strokes[fromIndex]->m_groupId.getCommonParentDepth(m_imp->m_strokes[toIndex]->m_groupId) >= 1)
		toIndex++;

	toIndex--;

	TGroupId groupId;

	if (fromIndex > 0 && m_imp->m_strokes[fromIndex - 1]->m_groupId.isGrouped(true) != 0)
		groupId = m_imp->m_strokes[fromIndex - 1]->m_groupId;
	else if (toIndex < (int)m_imp->m_strokes.size() - 1 && m_imp->m_strokes[toIndex + 1]->m_groupId.isGrouped(true) != 0)
		groupId = m_imp->m_strokes[toIndex + 1]->m_groupId;
	else
		groupId = TGroupId(this, true);

	for (int i = fromIndex; i <= toIndex || (i < (int)m_imp->m_strokes.size() && m_imp->m_strokes[i]->m_groupId.isGrouped(true) != 0); i++) {
		m_imp->m_strokes[i]->m_groupId.ungroup(groupId);
		changedStrokes.push_back(i);
	}

	notifyChangedStrokes(changedStrokes, std::vector<TStroke *>(), false);

	return toIndex - fromIndex + 1;
}

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

bool TVectorImage::isEnteredGroupStroke(int index) const
{
	return m_imp->m_insideGroup.isParentOf(getVIStroke(index)->m_groupId);
}

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

bool TVectorImage::enterGroup(int index)
{
	VIStroke *vs = getVIStroke(index);

	if (!vs->m_groupId.isGrouped())
		return false;

	int newDepth = vs->m_groupId.getCommonParentDepth(m_imp->m_insideGroup) + 1;

	TGroupId newGroupId = vs->m_groupId;

	while (newGroupId.getDepth() > newDepth)
		newGroupId = newGroupId.getParent();

	if (newGroupId == m_imp->m_insideGroup)
		return false;

	m_imp->m_insideGroup = newGroupId;
	return true;
}

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

int TVectorImage::exitGroup()
{
	if (m_imp->m_insideGroup == TGroupId())
		return -1;

	int i, ret = -1;
	for (i = 0; i < (int)m_imp->m_strokes.size(); i++) {
		if (m_imp->m_strokes[i]->m_groupId.getCommonParentDepth(m_imp->m_insideGroup) >= m_imp->m_insideGroup.getDepth()) {
			ret = i;
			break;
		}
	}

	assert(i != m_imp->m_strokes.size());

	m_imp->m_insideGroup = m_imp->m_insideGroup.getParent();
	return ret;
}

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

void TVectorImage::group(int fromIndex, int count)
{
	int i;
	assert(count >= 0);
	std::vector<int> changedStroke;

	TGroupId parent = TGroupId(this, false);

	for (i = 0; i < count; i++) {
		m_imp->m_strokes[fromIndex + i]->m_groupId = TGroupId(parent, m_imp->m_strokes[fromIndex + i]->m_groupId);
		changedStroke.push_back(fromIndex + i);
	}

	m_imp->rearrangeMultiGroup(); //see method's comment

	m_imp->regroupGhosts(changedStroke);

	notifyChangedStrokes(changedStroke, std::vector<TStroke *>(), false);

#ifdef _DEBUG
	m_imp->checkGroups();
#endif
}

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

int TVectorImage::getGroupDepth(UINT index) const
{
	assert(index < m_imp->m_strokes.size());

	return m_imp->m_strokes[index]->m_groupId.isGrouped();
}

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

int TVectorImage::areDifferentGroup(UINT index1, bool isRegion1, UINT index2, bool isRegion2) const
{
	return m_imp->areDifferentGroup(index1, isRegion1, index2, isRegion2);
}

//-------------------------------------------------------------------
/*this method is tricky.
it is not allow to have not-adiacent strokes  of same group.
but it can happen when you group  some already-grouped strokes creating sub-groups.

example: vi made of 5 strokes, before grouping  (N=no group)
N
N
1
1
N
after grouping became:
2
2
2-1
2-1
2
not allowed!

this method moves strokes, so that  adiacent strokes have same group.
so after calling rearrangeMultiGroup the vi became:
2
2
2
2-1
2-1

*/

void TVectorImage::Imp::rearrangeMultiGroup()
{
	UINT i, j, k;
	if (m_strokes.size() <= 0)
		return;
	for (i = 0; i < m_strokes.size() - 1; i++) {
		if (m_strokes[i]->m_groupId.isGrouped() && m_strokes[i + 1]->m_groupId.isGrouped() && m_strokes[i]->m_groupId != m_strokes[i + 1]->m_groupId) {
			TGroupId &prevId = m_strokes[i]->m_groupId;
			TGroupId &idToMove = m_strokes[i + 1]->m_groupId;
			for (j = i + 1; j < m_strokes.size() && m_strokes[j]->m_groupId == idToMove; j++)
				;
			if (j != m_strokes.size()) {
				j--; //now range i+1-j contains the strokes to be moved.
				//let's compute where to move them (after last
				for (k = j; k < m_strokes.size() && m_strokes[k]->m_groupId != prevId; k++)
					;
				if (k < m_strokes.size()) {
					for (; k < m_strokes.size() && m_strokes[k]->m_groupId == prevId; k++)
						;
					moveStrokes(i + 1, j - i, k, false);
					rearrangeMultiGroup();
					return;
				}
			}
		}
	}
}

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

int TVectorImage::Imp::areDifferentGroup(UINT index1, bool isRegion1, UINT index2, bool isRegion2) const
{
	TGroupId group1, group2;

	if (isRegion1) {
		TRegion *r = m_regions[index1];
		for (UINT i = 0; i < r->getEdgeCount(); i++)
			if (r->getEdge(i)->m_index >= 0) {
				group1 = m_strokes[r->getEdge(i)->m_index]->m_groupId;
				break;
			}
	} else
		group1 = m_strokes[index1]->m_groupId;
	if (isRegion2) {
		TRegion *r = m_regions[index2];
		for (UINT i = 0; i < r->getEdgeCount(); i++)
			if (r->getEdge(i)->m_index >= 0) {
				group2 = m_strokes[r->getEdge(i)->m_index]->m_groupId;
				break;
			}
	} else
		group2 = m_strokes[index2]->m_groupId;

	if (!group1 && !group2)
		return 0;

	if (group1 == group2)
		return -1;
	else
		return group1.getCommonParentDepth(group2);
}

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

int TGroupId::getCommonParentDepth(const TGroupId &id) const
{
	int size1 = m_id.size();
	int size2 = id.m_id.size();
	int count;

	for (count = 0; count < std::min(size1, size2); count++)
		if (m_id[size1 - count - 1] != id.m_id[size2 - count - 1])
			break;

	return count;
}

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

TGroupId::TGroupId(const TGroupId &parent, const TGroupId &id)
{
	assert(parent.m_id[0] > 0);
	assert(id.m_id.size() > 0);

	if (id.isGrouped(true) != 0)
		m_id.push_back(parent.m_id[0]);
	else {
		m_id = id.m_id;
		int i;
		for (i = 0; i < (int)parent.m_id.size(); i++)
			m_id.push_back(parent.m_id[i]);
	}
}

/*
bool TGroupId::sameParent(const TGroupId& id) const
{
assert(!m_id.empty() || !id.m_id.empty());
return m_id.back()==id.m_id.back();
}
*/

TGroupId TGroupId::getParent() const
{
	if (m_id.size() <= 1)
		return TGroupId();

	TGroupId ret = *this;
	ret.m_id.erase(ret.m_id.begin());
	return ret;
}

void TGroupId::ungroup(const TGroupId &id)
{
	assert(id.isGrouped(true) != 0);
	assert(!m_id.empty());

	if (m_id.size() == 1)
		m_id[0] = id.m_id[0];
	else
		m_id.pop_back();
}

bool TGroupId::operator==(const TGroupId &id) const
{
	if (m_id.size() != id.m_id.size())
		return false;
	UINT i;
	for (i = 0; i < m_id.size(); i++)
		if (m_id[i] != id.m_id[i])
			return false;

	return true;
}

bool TGroupId::operator<(const TGroupId &id) const
{
	assert(!m_id.empty() && !id.m_id.empty());
	int size1 = m_id.size();
	int size2 = id.m_id.size();
	int i;
	for (i = 0; i < std::min(size1, size2); i++)
		if (m_id[size1 - i - 1] != id.m_id[size2 - i - 1])
			return m_id[size1 - i - 1] < id.m_id[size2 - i - 1];

	return size1 < size2;
}

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

int TGroupId::isGrouped(bool implicit) const
{
	assert(!m_id.empty());
	assert(m_id[0] != 0);
	if (implicit)
		return (m_id[0] < 0) ? 1 : 0;
	else
		return (m_id[0] > 0) ? m_id.size() : 0;
}

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

TGroupId::TGroupId(TVectorImage *vi, bool isGhost)
{
	m_id.push_back((isGhost) ? -(++vi->m_imp->m_maxGhostGroupId) : ++vi->m_imp->m_maxGroupId);
}

#ifdef _DEBUG
void TVectorImage::Imp::checkGroups()
{
	TGroupId currGroupId;
	std::set<TGroupId> groupSet;
	std::set<TGroupId>::iterator it;
	UINT i = 0;

	while (i < m_strokes.size()) {
		//assert(m_strokes[i]->m_groupId!=currGroupId);
		//assert(i==0 || m_strokes[i-1]->m_groupId.isGrouped()!=m_strokes[i]->m_groupId.isGrouped()!=0 ||
		//       (m_strokes[i]->m_groupId.isGrouped()!=0 && m_strokes[i-1]->m_groupId!=m_strokes[i]->m_groupId));

		currGroupId = m_strokes[i]->m_groupId;
		it = groupSet.find(currGroupId);
		if (it != groupSet.end()) //esisteva gia un gruppo con questo id!
			assert(!"errore: due gruppi con lo stesso id!");
		else
			groupSet.insert(currGroupId);

		while (i < m_strokes.size() && m_strokes[i]->m_groupId == currGroupId)
			i++;
	}
}
#endif

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

bool TVectorImage::canMoveStrokes(int strokeIndex, int count, int moveBefore) const
{
	return m_imp->canMoveStrokes(strokeIndex, count, moveBefore);
}

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

//verifica se si possono spostare le stroke  da strokeindex a  strokeindex+count-1 prima della posizione moveBefore;
//per fare questo fa un vettore in cui mette tutti i gruppi nella  posizione dopo lo
//spostamento e verifica che sia un configurazione di gruppi ammessa.

bool TVectorImage::Imp::canMoveStrokes(int strokeIndex, int count, int moveBefore) const
{
	if (m_maxGroupId <= 1) //non ci sono gruppi!
		return true;

	int i, j = 0;

	std::vector<TGroupId> groupsAfterMoving(m_strokes.size());
	if (strokeIndex < moveBefore) {
		for (i = 0; i < strokeIndex; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = strokeIndex + count; i < moveBefore; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = strokeIndex; i < strokeIndex + count; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = moveBefore; i < (int)m_strokes.size(); i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;
	} else {
		for (i = 0; i < moveBefore; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = strokeIndex; i < strokeIndex + count; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = moveBefore; i < strokeIndex; i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;

		for (i = strokeIndex + count; i < (int)m_strokes.size(); i++)
			groupsAfterMoving[j++] = m_strokes[i]->m_groupId;
	}

	assert(j == (int)m_strokes.size());

	i = 0;
	TGroupId currGroupId;
	std::set<TGroupId> groupSet;

	while (i < (int)groupsAfterMoving.size()) {
		currGroupId = groupsAfterMoving[i];
		if (groupSet.find(currGroupId) != groupSet.end()) //esisteva gia un gruppo con questo id!
		{
			if (!currGroupId.isGrouped(true)) //i gruppi impliciti non contano
				return false;
		} else
			groupSet.insert(currGroupId);

		while (i < (int)groupsAfterMoving.size() && groupsAfterMoving[i] == currGroupId)
			i++;
	}

	return true;
}

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

void TVectorImage::Imp::regroupGhosts(std::vector<int> &changedStrokes)
{
	TGroupId currGroupId;
	std::set<TGroupId> groupMap;
	std::set<TGroupId>::iterator it;
	UINT i = 0;

	while (i < m_strokes.size()) {
		assert(m_strokes[i]->m_groupId != currGroupId);
		assert(i == 0 || m_strokes[i - 1]->m_groupId.isGrouped() != m_strokes[i]->m_groupId.isGrouped() != 0 ||
			   (m_strokes[i]->m_groupId.isGrouped() != 0 && m_strokes[i - 1]->m_groupId != m_strokes[i]->m_groupId));

		currGroupId = m_strokes[i]->m_groupId;
		it = groupMap.find(currGroupId);
		if (it != groupMap.end()) //esisteva gia un gruppo con questo id!
		{
			if (currGroupId.isGrouped() != 0)
				assert(!"errore: due gruppi con lo stesso id!");
			else //gruppo ghost; gli do un nuovo id
			{
				TGroupId newGroup(m_vi, true);

				while (i < m_strokes.size() && m_strokes[i]->m_groupId.isGrouped(true) != 0) {
					m_strokes[i]->m_groupId = newGroup;
					changedStrokes.push_back(i);
					i++;
				}
			}
		} else {
			groupMap.insert(currGroupId);
			while (i < m_strokes.size() &&
				   ((currGroupId.isGrouped(false) != 0 && m_strokes[i]->m_groupId == currGroupId) ||
					currGroupId.isGrouped(true) != 0 && m_strokes[i]->m_groupId.isGrouped(true) != 0)) {
				if (m_strokes[i]->m_groupId != currGroupId) {
					m_strokes[i]->m_groupId = currGroupId;
					changedStrokes.push_back(i);
				}
				i++;
			}
		}
	}
}

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

bool TVectorImage::canEnterGroup(int strokeIndex) const
{
	VIStroke *vs = m_imp->m_strokes[strokeIndex];

	if (!vs->m_groupId.isGrouped())
		return false;

	return m_imp->m_insideGroup == TGroupId() ||
		   vs->m_groupId != m_imp->m_insideGroup;
}

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

bool TVectorImage::inCurrentGroup(int strokeIndex) const
{
	return m_imp->inCurrentGroup(strokeIndex);
}

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

bool TVectorImage::Imp::inCurrentGroup(int strokeIndex) const
{
	return m_insideGroup == TGroupId() || m_insideGroup.isParentOf(m_strokes[strokeIndex]->m_groupId);
}

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

bool TVectorImage::selectable(int strokeIndex) const
{
	return (m_imp->m_insideGroup != m_imp->m_strokes[strokeIndex]->m_groupId &&
			inCurrentGroup(strokeIndex));
}

//--------------------------------------------------------------------------------------------------
namespace
{

bool containsNoSubregion(const TRegion *r, const TPointD &p)
{

	if (r->contains(p)) {
		for (unsigned int i = 0; i < r->getSubregionCount(); i++)
			if (r->getSubregion(i)->contains(p))
				return false;
		return true;
	} else
		return false;
}
};

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

int TVectorImage::getGroupByStroke(UINT index) const
{
	VIStroke *viStroke = getVIStroke(index);
	return viStroke->m_groupId.m_id.back();
}

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

int TVectorImage::getGroupByRegion(UINT index) const
{
	TRegion *r = m_imp->m_regions[index];
	for (UINT i = 0; i < r->getEdgeCount(); i++)
		if (r->getEdge(i)->m_index >= 0) {
			return m_imp->m_strokes[r->getEdge(i)->m_index]->m_groupId.m_id.back();
		}

	return -1;
}

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

int TVectorImage::pickGroup(const TPointD &pos, bool onEnteredGroup) const
{
	if (onEnteredGroup && isInsideGroup() == 0)
		return -1;

	//double maxDist2 = 50*tglGetPixelSize2();

	int strokeIndex = getStrokeCount() - 1;

	while (strokeIndex >= 0) // ogni ciclo di while esplora un gruppo; ciclo sugli stroke
	{
		if (!isStrokeGrouped(strokeIndex)) {
			strokeIndex--;
			continue;
		}

		bool entered = isInsideGroup() > 0 && isEnteredGroupStroke(strokeIndex);

		if ((onEnteredGroup || entered) &&
			(!onEnteredGroup || !entered)) {
			strokeIndex--;
			continue;
		}

		int currStrokeIndex = strokeIndex;

		while (strokeIndex >= 0 && getCommonGroupDepth(strokeIndex, currStrokeIndex) > 0) {
			TStroke *s = getStroke(strokeIndex);
			double outT;
			int chunkIndex;
			double dist2;
			bool ret = s->getNearestChunk(pos, outT, chunkIndex, dist2);
			if (ret) {
				TThickPoint p = s->getChunk(chunkIndex)->getThickPoint(outT);
				if (p.thick < 0.1)
					p.thick = 1;
				if (sqrt(dist2) <= 1.5 * p.thick)
					return strokeIndex;
			}

			/*TThickPoint p = s->getThickPoint(s->getW(pos));
    
   double dist = tdistance( TThickPoint(pos,0), p);
    if (dist<1.2*p.thick/2.0)
      return strokeIndex;*/
			strokeIndex--;
		}
	}

	strokeIndex = getStrokeCount() - 1;
	int ret = -1;

	while (strokeIndex >= 0) // ogni ciclo di while esplora un gruppo; ciclo sulle regions
	{
		if (!isStrokeGrouped(strokeIndex)) {
			strokeIndex--;
			continue;
		}

		bool entered = isInsideGroup() > 0 && isEnteredGroupStroke(strokeIndex);

		if ((onEnteredGroup || entered) &&
			(!onEnteredGroup || !entered)) {
			strokeIndex--;
			continue;
		}

		TRegion *currR = 0;
		for (UINT regionIndex = 0; regionIndex < getRegionCount(); regionIndex++) {
			TRegion *r = getRegion(regionIndex);

			int i, regionStrokeIndex = -1;
			for (i = 0; i < (int)r->getEdgeCount() && regionStrokeIndex < 0; i++)
				regionStrokeIndex = r->getEdge(i)->m_index;

			if (regionStrokeIndex >= 0 && sameSubGroup(regionStrokeIndex, strokeIndex) && containsNoSubregion(r, pos)) {
				if (!currR || currR->contains(*r)) {
					currR = r;
					ret = regionStrokeIndex;
				}
			}
		}
		if (currR != 0) {
			assert(m_palette);
			const TSolidColorStyle *st = dynamic_cast<const TSolidColorStyle *>(m_palette->getStyle(currR->getStyle()));
			if (!st || st->getMainColor() != TPixel::Transparent)
				return ret;
		}

		while (strokeIndex > 0 && getCommonGroupDepth(strokeIndex, strokeIndex - 1) > 0)
			strokeIndex--;
		strokeIndex--;
	}

	return -1;
}

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

int TVectorImage::pickGroup(const TPointD &pos) const
{
	int index;
	if ((index = pickGroup(pos, true)) == -1)
		return pickGroup(pos, false);

	return index;
}

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