ldforge: comparison src/editmodes/magicWandMode.cpp

-:e2755ccf3667
+:e75cc5bff076
 #include "magicWandMode.h"
 #include "../lddocument.h"
 #include "../mainwindow.h"
 #include "../canvas.h"
-MagicWandMode::MagicWandMode (Canvas* canvas) :
+MagicWandMode::MagicWandMode(Canvas* canvas) :
-Super (canvas)
+	Super {canvas}
 {
+	QSet<LineSegment> boundarySegments;
 	// Get vertex<->object data
-	for (LDObject* obj : currentDocument()->objects())
+	for (const QModelIndex& index : currentDocument()->indices())
 	{
 		// Note: this deliberately only takes vertex-objects into account.
 		// The magic wand does not process subparts.
-		for (int i = 0; i < obj->numVertices(); ++i)
+		LDObject* object = currentDocument()->lookup(index);
-			m_vertices[obj->vertex (i)] << obj;
+		for (int i = 0; i < object->numVertices(); ++i)
+		{
+			LineSegment segment {
+				object->vertex(i),
+				object->vertex((i + 1) % object->numVertices())
+			};
+			m_vertices[object->vertex(i)].insert(index);
+			if (object->type() == LDObjectType::EdgeLine)
+				boundarySegments.insert(segment);
+			else
+				this->segments[segment].insert(index);
+		}
 	}
+	// Remove all edge lines from the set of available segments because they get in the way.
+	for (const LineSegment& boundarySegment : boundarySegments)
+		this->segments.remove(boundarySegment);
 }
 EditModeType MagicWandMode::type() const
 {
 	return EditModeType::MagicWand;
 }
-void MagicWandMode::fillBoundaries (LDObject* obj, QVector<BoundaryType>& boundaries, QSet<LDObject*>& candidates)
+void MagicWandMode::edgeFill(
-{
+	QModelIndex index,
-	// All boundaries obviously share vertices with the object, therefore they're all in the list
+	QItemSelection& selection,
-	// of candidates.
+	QSet<QModelIndex>& processed
-	for (LDObject* candidate : candidates)
+) const {
+	QItemSelection result;
+	processed.insert(index);
+	result.select(index, index);
+	QSet<QPersistentModelIndex> candidates;
+	LDObject* object = currentDocument()->lookup(index);
+	// Get the list of objects that touch this object, i.e. share a vertex with it.
+	for (int i = 0; i < object->numVertices(); ++i)
+		candidates |= m_vertices[object->vertex(i)];
+	candidates.remove(index);
+	for (const QModelIndex& candidate : candidates)
 	{
-		if (not isOneOf(candidate->type(), LDObjectType::EdgeLine, LDObjectType::ConditionalEdge)
+		LDObject* candidateObject = currentDocument()->lookup(candidate);
-			or candidate->vertex (0) == candidate->vertex (1))
+		if (candidateObject->type() == LDObjectType::EdgeLine
+			and candidateObject->color() == object->color()
+		) {
+			selection.select(candidate, candidate);
+			if (not processed.contains(candidate))
+				edgeFill(candidate, selection, processed);
+		}
+	}
+}
+void MagicWandMode::surfaceFill(
+	QModelIndex index,
+	QItemSelection& selection,
+	QSet<QModelIndex>& processed
+) const {
+	LDObject* object = currentDocument()->lookup(index);
+	selection.select(index, index);
+	processed.insert(index);
+	for (int i = 0; i < object->numVertices(); i += 1)
+	{
+		Vertex v_1 = object->vertex(i);
+		Vertex v_2 = object->vertex((i + 1) % object->numVertices());
+		LineSegment segment {v_1, v_2};
+		for (const QModelIndex& candidate : this->segments[segment])
 		{
-			continue;
+			if (currentDocument()->lookup(candidate)->color() == object->color())
-		}
+			{
+				selection.select(candidate, candidate);
-		int matches = 0;
+				if (not processed.contains(candidate))
+					surfaceFill(candidate, selection, processed);
-		for (int i = 0; i < obj->numVertices(); ++i)
-		{
-			if (not isOneOf (obj->vertex (i), candidate->vertex (0), candidate->vertex (1)))
-				continue;
-			if (++matches == 2)
-			{
-				// Boundary found. If it's an edgeline, add it to the boundaries list, if a
-				// conditional line, select it.
-				if (candidate->type() == LDObjectType::ConditionalEdge)
-					m_selection << candidate;
-				else
-					boundaries.append (std::make_tuple (candidate->vertex (0), candidate->vertex (1)));
-				break;
 			}
 		}
 	}
 }
-void MagicWandMode::doMagic (LDObject* obj, MagicWandMode::MagicType type)
+QItemSelection MagicWandMode::doMagic(const QModelIndex& index) const
 {
-	if (obj == nullptr)
+	QItemSelection selection;
+	LDObject* object = currentDocument()->lookup(index);
+	if (object)
 	{
-		if (type == Set)
+		QSet<QModelIndex> processed;
-			currentDocument()->clearSelection();
-		return;
+		if (object->type() == LDObjectType::EdgeLine)
+			edgeFill(index, selection, processed);
+		else if (object->numPolygonVertices() >= 3)
+			surfaceFill(index, selection, processed);
 	}
-	int matchesneeded = 0;
+	return selection;
-	QVector<BoundaryType> boundaries;
-	LDObjectType objtype = obj->type();
-	if (type != InternalRecursion)
-	{
-		m_selection.clear();
-		m_selection.append (obj);
-	}
-	switch (obj->type())
-	{
-		case LDObjectType::EdgeLine:
-		case LDObjectType::ConditionalEdge:
-			matchesneeded = 1;
-			break;
-		case LDObjectType::Triangle:
-		case LDObjectType::Quadrilateral:
-			matchesneeded = 2;
-			break;
-		default:
-			return;
-	}
-	QSet<LDObject*> candidates;
-	// Get the list of objects that touch this object, i.e. share a vertex
-	// with this.
-	for (int i = 0; i < obj->numVertices(); ++i)
-		candidates += m_vertices[obj->vertex (i)];
-	// If we're dealing with surfaces, get a list of boundaries.
-	if (matchesneeded > 1)
-		fillBoundaries (obj, boundaries, candidates);
-	for (LDObject* candidate : candidates)
-	{
-		try
-		{
-			// If we're doing this on lines, we need exact type match. Surface types (quads and
-			// triangles) can be mixed. Also don't consider self a candidate, and don't consider
-			// objects we have already processed.
-			if ((candidate == obj) or
-				(candidate->color() != obj->color()) or
-				(m_selection.contains (candidate)) or
-				(matchesneeded == 1 and (candidate->type() != objtype)) or
-				((candidate->numVertices() > 2) ^ (matchesneeded == 2)))
-			{
-				throw 0;
-			}
-			// Now ensure the two objects share enough vertices.
-			QVector<Vertex> matches;
-			for (int i = 0; i < obj->numVertices(); ++i)
-			{
-				for (int j = 0; j < candidate->numVertices(); ++j)
-				{
-					if (obj->vertex(i) == candidate->vertex(j))
-					{
-						matches << obj->vertex(i);
-						break;
-					}
-				}
-			}
-			if (countof(matches) < matchesneeded)
-				throw 0; // Not enough matches.
-			// Check if a boundary gets in between the objects.
-			for (auto boundary : boundaries)
-			{
-				if (isOneOf (matches[0], std::get<0> (boundary), std::get<1> (boundary)) and
-					isOneOf (matches[1], std::get<0> (boundary), std::get<1> (boundary)))
-				{
-					throw 0;
-				}
-			}
-			m_selection.append (candidate);
-			doMagic (candidate, InternalRecursion);
-		}
-		catch (int&)
-		{
-			continue;
-		}
-	}
-	switch (type)
-	{
-	case Set:
-		currentDocument()->clearSelection();
-	case Additive:
-		for (LDObject* obj : m_selection)
-			currentDocument()->addToSelection(obj);
-		break;
-	case Subtractive:
-		for (LDObject* obj : m_selection)
-			currentDocument()->removeFromSelection(obj);
-		break;
-	case InternalRecursion:
-		break;
-	}
 }
 bool MagicWandMode::mouseReleased (MouseEventData const& data)
 {
 	if (Super::mouseReleased (data))
 		return true;
 	if (data.releasedButtons & Qt::LeftButton and not data.mouseMoved)
 	{
-		MagicType wandtype = MagicWandMode::Set;
+		QItemSelection selection = this->doMagic(renderer()->pick(data.ev->x(), data.ev->y()));
+		QItemSelectionModel::SelectionFlags command = QItemSelectionModel::ClearAndSelect;
 		if (data.keymods & Qt::ShiftModifier)
-			wandtype = MagicWandMode::Additive;
+			command = QItemSelectionModel::Select;
 		else if (data.keymods & Qt::ControlModifier)
-			wandtype = MagicWandMode::Subtractive;
+			command = QItemSelectionModel::Deselect;
-		doMagic (renderer()->pick (data.ev->x(), data.ev->y()), wandtype);
+		renderer()->selectionModel()->select(selection, command);
 		return true;
 	}
 	return false;
 }

Mercurial > ldforge / file comparison

comparison: src/editmodes/magicWandMode.cpp

src/editmodes/magicWandMode.cpp