Esempio n. 1
0
int SymmetryObject::checkNewEP()
{
	int siz = newEP.size();	// antal vertices i kedja
	cout << "siz = " << siz << endl;
	vector<VEC> wc;

	cout << "skriver ut ala newEP: " << endl;
	for (int i=0; i<siz; i++) {
		wc.push_back(getWcFromPoint(newEP[i]));
		cout << i << ":\t" << wc[i] << "\t" << newEP[i].toString() << endl;
	}


	if (siz <= 1) {
		cout << "return 1: siz = " << siz << "<= 1 " << endl;
		return 1;
	}


		// gå genom alla och se om någon om två vertices sträcker sig för långt
	Prefix pfxDiff;
	for (int i=siz-2; i>=0; i--)
	{
		//pfxDiff = (newEP[siz-1].Pfx / newEP[i].Pfx);
		pfxDiff = (newEP[i].Pfx.getInverse() * newEP[siz-1].Pfx);
		pfxDiff.simplify();

		switch(pfxDiff.size())
		{
		case 0:
		case 1:
			break;
		case 2:
			if ((pfxDiff[0]^pfxDiff[1]) != 6) {
				cout << "return 0: pfxDiff[0]^pfxDiff[1] = " << (pfxDiff[0]^pfxDiff[1]) << " != 6" << endl;
				cout << "PfxDiff = ";
				pfxDiff.print();
				return 0;
			}
			break;
		default:
			cout << "return 0: pfxDiff[0].size() > 2" << endl;
			return 0;
		}
	}


	cout << "pfxDiff: " << pfxDiff.toString() << endl;
	int pfxDiffSiz = pfxDiff.size();


		// kontrollera att den inte är bend åt fel håll
	if (siz > 2) {
		if (~(wc[siz-1]-wc[siz-2]) * (wc[siz-3]-wc[siz-2]) < 0)
		{
			cout << "Bend towards vrong hool" << endl;
			return 0;
		}
	}

		//kontrollera så ingen är ansluten A -> B

		//kontrollera att inga korsningar existerar


		// finns det enclosed Points:
	VEC A[3];
	list<Point> enclosedPoints;
	if (siz >= 3) {
		A[0] = wc[0];
		A[1] = wc[siz-2];
		A[2] = wc[siz-1];
		int extraPoints = getEnclosedPoints(A, enclosedPoints);

		cout << "enclosed Points: " << extraPoints << endl;
		for (list<Point>::iterator itP = enclosedPoints.begin(); itP != enclosedPoints.end(); itP++)
			cout << "\t" << itP->toString() << endl;

		if (extraPoints > 0) {
			cout << "det fanns enclosed punkter" << endl;
			return 0;
		}
	}

		// kontrollera om den inte återvänder till samma index
	if (newEP[siz-1].index != newEP[0].index) {
		cout << "index[siz-1] != index[0] so returna 1" << endl;
		return 1;
	}


		// bestäm vad det är för typ av face
	switch(pfxDiffSiz) {
	case 0:
		cout << "Not centered" << endl;
		if (siz == 2) {
			cout << "siz = 2 och returnar till samma punkt" << endl;
			return 0;
		}
		return NOT_CENTERED;
	case 1: {
		if (pfxDiff[0] == VP) {
			cout << "pfxDiff[0] = VP" << endl;
			if (vertexPointActive) {
				cout << "kan inte skapa VCF för VP är aktiv, därför return 1" << endl;
				return 1;
			}

				// gör koll om det finns enclosed Vertieces i [wc[0], wc[siz-1], getWcFromPoint(Point(E_ToBe[0].fr.Pfx))]
			A[0] = wc[0];
			A[1] = wc[siz-1];
			A[2] = getWcFromPoint(Point(newEP[0].Pfx, VERTEX_CENTERED));
			this->getEnclosedPoints(A, enclosedPoints);
			if (enclosedPoints.size() > 0)
			{
				cout << "kan inte skapa VCF för att man enclosar Points, därför return 1";
				return 1;
			}

				// kontrollera att sista och påföljande edge inte buktar åt fel håll., då returneras 1

			cout << "lyckades skapa VCF, return VERTEX_CENTERED" << endl;
			return VERTEX_CENTERED;

		} else if (pfxDiff[0] == FP) {
			cout << "pfxDiff[0] = FP" << endl;
			if (facePointActive) {
				cout << "kan inte skapa FCF för FP är aktiv, därför return 1" << endl;
				return 1;
			}

				// gör koll om det finns enclosed Vertieces i [wc[0], wc[siz-1], getWcFromPoint(Point(E_ToBe[0].fr.Pfx))]
			A[0] = wc[0];
			A[1] = wc[siz-1];
			A[2] = getWcFromPoint(Point(newEP[0].Pfx, FACE_CENTERED));
			this->getEnclosedPoints(A, enclosedPoints);
			if (enclosedPoints.size() > 0)
			{
				cout << "kan inte skapa VCF för att man enclosar Points, därför return 1";
				return 1;
			}

				// kontrollera att sista och påföljande edge inte buktar åt fel håll., då returneras 1

			cout << "lyckades skapa FCF, return FACE_CENTERED" << endl;
			return FACE_CENTERED;
		} else {
			cout << "pfxDiffSiz = 1, men pfxDiff[0] = " << (pfxDiff[0] == VN? "VN": "FN") << ", return 1" << endl;
			return 1;
		}
	}
	case 2: {
		cout << "pfxDiff[i]^pfxDiff[siz-1] != 6" << endl;

		if (edgePointActive) {
			cout << "kan inte meeta edge opposite Point om EP active, return 0" << endl;
			return 0;
		}

			// behöver inte leta efter points inom något område för allt är redan avsökt.


			// kontrollera att sista och påföljande edge inte buktar åt fel håll., då returneras 0

		cout << "lyckades skapa ECF, return EDGE_CENTERED" << endl;
		return EDGE_CENTERED;
		break;
	}
	default:
		cout << "ska inte komma hit till default, return 0" << endl;
		return 0;
		break;
	}


	/*
n[]
    om e<3                    0
    annars                    -1

n[VP]    om VCV = true                1
    om innesluten vertex i A, B, VCP    1
    annars                     -2

n[VP FP]
n[FN VN]    om e<2                1
    om ECV = true                0
    annars                    -3

n[FP]    om FCV = true                1
    om innesluten vertex i A, B, FCP    1
    annars                    -4
	 */

	cout << "kom hit " << endl;
	return 1;


	/*

Första = A
Sista  = B

Prefix pfxDiff = (B.Pfx / A.Pfx).simplify();
switch(pfxDiff.size())
{
    case 1:
        break;
    case 2:
        if (pfxDiff[0]^pfxDiff[1]!=6)
            0
        break;
    default:
            0
        break;
}

kontrollera så ingen är ansluten A -> B

Face-centered vertex = FCV
Face-centered position = FCP

2    Färdig
1    Fortsätt leta
0    Förstörd ta bort
-1    Not centered
-2    vertex centered
-3    edge centered
-4    face centered


c = inneslutna hörn
e = antal edges

c>0                        0

n[]
    om e<3                    0
    annars                    -1

n[VP]    om VCV = true                1
    om innesluten vertex i A, B, VCP    1
    annars                     -2

n[VP FP]
n[FN VN]    om e<2                1
    om ECV = true                0
    annars                    -3

n[FP]    om FCV = true                1
    om innesluten vertex i A, B, FCP    1
    annars                    -4

	 * */


}
Esempio n. 2
0
bool SymmetryObject::addNewEP(int sluten)
{
	//cout << "i addfacetobe so is sluten = " << sluten << endl;
			//vector<edge>::iterator ite = E_ToBe.end();
	int sizE = E.size();

	//		Fixa:
	// Rootera tillbaka ytan så att början
	//och slutet alltid rör  en rootPoint.
	Prefix draBortPfxInv = E_ToBe[0].fr.Pfx;//.getSize();
	cout << "The following prefix ska dras away" << endl;
	draBortPfxInv.print();
	draBortPfxInv = draBortPfxInv.getInverse();

	for (unsigned int i=0; i<E_ToBe.size()-1; i++)
	{
		edge edgeToPushBack;

		Prefix enAnnanPrefixIgen = draBortPfxInv;
		enAnnanPrefixIgen.rotate(E_ToBe[i].fr.Pfx);
		enAnnanPrefixIgen.simplify();
		edgeToPushBack.fr.Pfx = enAnnanPrefixIgen;
		edgeToPushBack.fr.index = E_ToBe[i].fr.index;

		enAnnanPrefixIgen = draBortPfxInv;
		enAnnanPrefixIgen.rotate(E_ToBe[i].to.Pfx);
		enAnnanPrefixIgen.simplify();
		edgeToPushBack.to.Pfx = enAnnanPrefixIgen;
		edgeToPushBack.to.index = E_ToBe[i].to.index;

		Prefix PfxNext;
		Prefix PfxPrev;

		switch (sluten) {
			case NOT_CENTERED: {
				edgeToPushBack.next = Edge(PfxNext, (i==E_ToBe.size()-2? sizE: sizE + i + 1));
				edgeToPushBack.prev = Edge(PfxPrev, (i==0? sizE + E_ToBe.size() - 2: sizE + i - 1));
				break;
			}
			case VERTEX_CENTERED: {

				if (i==0)
					PfxPrev.rotate(VN);
				if (i==E_ToBe.size()-2)
					PfxNext.rotate(VP);
				edgeToPushBack.next = Edge(PfxNext, (i==E_ToBe.size()-2? sizE: sizE + i + 1));
				edgeToPushBack.prev = Edge(PfxPrev, i==0? sizE + E_ToBe.size() - 2: sizE + i - 1);
				//edgeToPushBack.next = (i==E_ToBe.size()-2? Edge(Pfx, sizE): Edge(Prefix(), sizE + i + 1));
				break;
			}
			case EDGE_CENTERED: {
				Prefix cpPrefixHelvete;

				cpPrefixHelvete = E_ToBe[E_ToBe.size()-1].fr.Pfx;
				cpPrefixHelvete.rotate(draBortPfxInv);

				cout << "when it is done, it becomasar: ";
				cpPrefixHelvete.print();
				cout << endl;

				if (i==0) {
					PfxPrev = cpPrefixHelvete;
				}


				if (i==E_ToBe.size()-2) {
					PfxNext = cpPrefixHelvete;
				}

				edgeToPushBack.next = Edge(PfxNext, (i==E_ToBe.size()-2? sizE: sizE + i + 1));
				edgeToPushBack.prev = Edge(PfxPrev, (i==0? sizE + E_ToBe.size() - 2: sizE + i - 1));
				break;
			}
			case FACE_CENTERED: {
				Prefix PfxNext;
				Prefix PfxPrev;

				if (i==0)
					PfxPrev.rotate(FN);
				if (i==E_ToBe.size()-2)
					PfxNext.rotate(FP);
				edgeToPushBack.next = Edge(PfxNext, (i==E_ToBe.size()-2? sizE: sizE + i + 1));
				edgeToPushBack.prev = Edge(PfxPrev, (i==0? sizE + E_ToBe.size() - 2: sizE + i - 1));
				break;
			}
			default:
				cout << "symmetryObject.cpp\tHIT SKA DEN INTE KOMMA!!!!!!!!!!!" << endl;
				break;
		}

			// kolla genom om man kan hitta någon opposite
		cout << endl;
		//int kortastePrefix = 10000000;
		edgeToPushBack.oppo.index = -1;
		//edgeToPushBack.





			// kolla genom om man kan hitta någon opposite, IGEN
		if (edgeToPushBack.oppo.index == -1) {
			for (unsigned int j=0; j<E.size(); j++)
			{
				Prefix oppositeOfPrefix;
				//if (E[j].isOppositeOf(E_ToBe[i], &oppositeOfPrefix)) {
				if (E[j].isOppositeOf(edgeToPushBack, &oppositeOfPrefix)) {
					edgeToPushBack.oppo = Edge(oppositeOfPrefix.getInverse(), j);
					E[j].oppo = Edge(oppositeOfPrefix, i + sizE);

					break;
				}
			}
		}
		//cout << "a" << endl;

		Prefix oppositeOfPrefix;
		if (edgeToPushBack.oppo.index == -1)
		{
			//if (E_ToBe[i].isOppositeOf(E_ToBe[i], &oppositeOfPrefix)) {
			if (E_ToBe[i].isOppositeOf(edgeToPushBack, &oppositeOfPrefix)) {
				edgeToPushBack.oppo = Edge(oppositeOfPrefix.getInverse(), i + sizE);
			}
		}

		E.push_back(edgeToPushBack);
	}

	F.push_back(face(sizE, E.size() - sizE, sluten));
	cout << "          *****************************************            " << endl;
	cout << "tjena nu is jag here" << endl;
		// uppdatera GUI:et
	char strToSend[200];
		// id, first edge, num of edges, type, görasigplatt-styrka
	snprintf(strToSend, 200, "%d,%d,%d,%d", F.size()-1, sizE, E.size() - sizE, sluten);
	cout << "detta skickas when face skapas: " << strToSend << endl;

	E_ToBe.clear();
	printAll();
	return true;
}
Esempio n. 3
0
bool Point::equalTo(Point &A) {
	Prefix subPfx = Pfx.difference(A.Pfx);
	bool keepTrying = (index<-1);
	subPfx.simplify();

	//cout << endl << "subPfx before: ";
	//subPfx.print();
	//cout << endl;


	//for (list<TYP>::reverse_iterator rit = R.rbegin(); rit != R.rend(); rit++)
		//toReturn.R.push_back(INV_ROTATION(*rit));

	int previousEcTYP = 0;
	int k = 0;

	keepTrying = true;
	for (list<TYP>::reverse_iterator ritR = subPfx.R.rbegin(); keepTrying && ritR != subPfx.R.rend();)
	{
		k++;
		//cout << "now is ritR = ";
		//rotationPrint(*ritR);
		//cout << endl;

		if (index == VERTEX_CENTERED && (*ritR == VN || *ritR == VP)) {
			//cout << "VC" << endl;
			/*subPfx.R.erase(--(ritR.base()));
			ritR = subPfx.R.rbegin();*/
			ritR = list<TYP>::reverse_iterator(subPfx.R.erase(--(ritR.base())));
			//cout << "ritR efter erase: ";
			//rotationPrint(*ritR);
			//cout << endl;
		} else if (index == FACE_CENTERED && (*ritR == FN || *ritR == FP)) {
			//cout << "FC" << endl;
			ritR = list<TYP>::reverse_iterator(subPfx.R.erase(--(ritR.base())));
			//cout << "ritR efter erase: ";
			//rotationPrint(*ritR);
		} else if (index == EDGE_CENTERED) {
			//TYP ritRold = *ritR;
			if ((previousEcTYP == FP && *ritR == VP) || (previousEcTYP == VN && *ritR == FN)) {
				//cout << "ECa" << endl;
				subPfx.R.pop_back();
				subPfx.R.pop_back();
				ritR = subPfx.R.rbegin();
				//ritR = list<TYP>::reverse_iterator(subPfx.R.erase(--(ritR.base())));
				//ritR = list<TYP>::reverse_iterator(subPfx.R.erase(--(ritR.base())));
				previousEcTYP = 0;
			} else if ((previousEcTYP == VN && *ritR == FP) || (previousEcTYP == VN && *ritR == FP)){
				//cout << "ECd" << endl;
				subPfx.R.pop_back();
				subPfx.R.pop_back();
				subPfx.R.push_back(FN);
				ritR = subPfx.R.rbegin();
				subPfx.print();
				//cout << endl;
				subPfx.simplify();
				subPfx.print();
				//cout << endl;
				previousEcTYP = 0;
				//cout << endl;
			} else if (previousEcTYP == 0 && (*ritR == FP || *ritR == VN)) {
				//cout << "ECb" << endl;
				previousEcTYP = *ritR;
				ritR++;
			} else {
				//cout << "ECc" << endl;
				keepTrying = false;
			}
		} else {

			//cout << "0" << endl;
			keepTrying = false;
		}
		if (k > 10)
			break; 
	}


	//cout << endl << "subPfx efter: ";
	//subPfx.print();
	//cout << endl;

	return (subPfx.size() == 0);
}