// add: add word to suffix list, update prefix
void add(Prefix& prefix, const string& s)
{
	if (prefix.size() == NPREF) {
		statetab[prefix].push_back(s);
		prefix.pop_front();
	}
	prefix.push_back(s);
}
Exemple #2
0
void AddEntry(Prefix& prefix, const string& suffix)
{
	if (prefix.size() == PREFIX_LENGTH) {
		dictionary[prefix].push_back(suffix);
		prefix.pop_front();
	}
	prefix.push_back(suffix);
}
Exemple #3
0
 void add(Prefix& prefix, string& new_word)
 {
      if(prefix.size() == prefix_len_)
      {
          state_list[prefix].push_back(new_word);
          prefix.pop_front();
      } 
      prefix.push_back(new_word);
 }
Exemple #4
0
	// 	detta är en fullständig test som kollar inte 
	//	bara sista tillagda edgen utan alla edges i facet
	// 		returnerar:
	// 0 om det är felaktigt
	// 1 om det är ok men icke sluten
	// 2 om face är ok.
	//#define NOT_CENTERED		(-1)
	//#define VERTEX_CENTERED	(-2)
	//#define EDGE_CENTERED		(-3)
	//#define FACE_CENTERED		(-4)
int SymmetryObject::checkE_ToBe()
{
	/*VEC AA[3];
	AA[0] = VEC(0.154, 0.07);
	AA[1] = VEC(3.738, 2.) / 9.;
	AA[2] = VEC(0.622, 7.7) /3.;*/


	int siz = E_ToBe.size();
	if (siz <= 1)
		return 1;

		// kolla om den roterar i positiv z-riktning
	VEC fr_ = getWcFromPoint(E_ToBe[0].fr);
	VEC to_ = getWcFromPoint(E_ToBe[0].to);
	VEC edge0_ = to_ - fr_;
	VEC edge1_;
	for (int i=1; i<siz-1; i++)
	{
		fr_ = to_;
		to_ = getWcFromPoint(E_ToBe[i].to);
		edge1_ = to_ - fr_;

		if ((~edge0_ * edge1_) < 0.0)
		{
			cout << "******** EDGES INVALID ********* " << endl;
			cout << "edge0: " << edge0_;
			//edge0_.print();
			cout << "\t edge1: " << edge1_ << endl;
			
			return 0;
		}
		edge0_ = edge1_;
	}



		// kolla om den korsar sig själv
	for (int i=2; i<siz-1; i++)
	{
		for (int j=0; j<i-1; j++)
		{
			VEC Afr_ = getWcFromPoint(E_ToBe[j].fr);
			VEC Ato_ = getWcFromPoint(E_ToBe[j].to);
			VEC Bfr_ = getWcFromPoint(E_ToBe[i].fr);
			VEC Bto_ = getWcFromPoint(E_ToBe[i].to);
			
			VEC P_ = ~(Afr_ - Bfr_);
			VEC Q_ = Ato_ - Afr_;
			VEC R_ = Bto_ - Bfr_;

			double divider_ = Q_ * ~R_;
			double a_ = (Q_ * P_) / divider_;
			double b_ = (R_ * P_) / divider_;

			//cout << "a_: " << a_ << "\tb_: " << b_ << endl;
			if (a_>0 && a_<1 && b_>0 && b_<1)
			{
				cout << "EDGES FUNKAR ICKE ICKE ICKE!!!" << endl;
				cout << "korsar varandra i=" << i << " och j=" << j << endl;
				cout << "a_: " << a_ << "\tb_: " << b_ << endl;
				return 0;
			}
		}
	}

		// kontrollera att inga Points är inkapslade av markeringen.
	list<Point> enclosedPoints;
	VEC A[3];
	A[0] = getWcFromPoint(E_ToBe[0].fr);
	cout << "nu is siz = " << siz << endl;
	for (int i=1; i<siz-2; i++)
	{
		A[1] = getWcFromPoint(E_ToBe[i].fr);
		A[2] = getWcFromPoint(E_ToBe[i+1].fr);

		int extraPoints = getEnclosedPoints(A, enclosedPoints);
		if (extraPoints)
		{
			cout << "extraPoints > 0 when i = " << i << endl;
			for (int j=0; j<3; j++)
				cout << "A[" << j << "]: " << A[j] << endl;
		}
	}
	
	cout << " ************* " << endl;

	cout << "Enclosed Points: " << enclosedPoints.size() << " st." << endl;
	for (list<Point>::iterator itP = enclosedPoints.begin(); itP != enclosedPoints.end(); itP++){
		itP->print();
		cout << "\t" << getWcFromPoint(*itP) << endl;
	}
	cout << " ************* " << endl;


	if (enclosedPoints.size() > 0) {
		cout << "enclosedPoints.size != 0, exit" << endl;
		return 0;
	}



		// Här kontrolleras om kanterna i ytan är sluten:
	if (E_ToBe[siz - 1].fr.index == E_ToBe[0].fr.index)
	{
			// Nu kan den vara sluten 
		Prefix pfxDiff = E_ToBe[0].fr.Pfx.difference(E_ToBe[siz-1].fr.Pfx);
		cout << "prefix difference: ";
		pfxDiff.print();
		cout << endl;	

			// ytan börjar och slutar i samma punkt.
			// Förutsatt att dne kommit hit ner i funktionen
			// så är kanterna slutna till en yta. Toppen!
		if (pfxDiff.size() == 0)
		{
			cout << "startar och slutar i samma punkt :) " << endl;
			return NOT_CENTERED;
		}

			// om pfxDiff = [VP] så kan det vara en Vertex-Centered Face.
		if (pfxDiff.size() == 1 && pfxDiff[0] == VP)
		{
			cout << "Det is en VP rotation detta :) " << endl;
			
			
				//kontrollera så att inga punkter existerar i det området
			if (vertexPointActive)
				return 1;

			Orientation ori(pat);
			ori.rotate(E_ToBe[0].fr.Pfx);
			VEC A[3];
			A[0] = getWcFromPoint(E_ToBe[0].fr);
			A[1] = getWcFromPoint(E_ToBe[siz-1].fr);
			A[2] = ori.getWCFromOC(VEC(0,0));
			list<Point> enclosedPoints;
			getEnclosedPoints(A, enclosedPoints);

			cout << "the following killar ligger in the way: " << endl;
			for (list<Point>::iterator itP = enclosedPoints.begin(); itP != enclosedPoints.end(); itP++){
				itP->print();
				cout << endl;
			}

				// Det är ingen vertexcentered face för den har punkter inom sig.
			if (enclosedPoints.size() > 0)
				return 1;


				// kontrollera 
			if (siz == 2)
				return VERTEX_CENTERED;


			// Kontrollera så att polygonen är konvex om 
			// den är sluten.

				// här kan man vara ute på riktigt hal is om 
				// man exempelvis INTE bygger 10 edgeiga faces
				// i ikosaeder-symmetri, utan istället bygger
				// snorspetsiga fula trianglar. Men skyll dig själv!
			A[0] = getWcFromPoint(E_ToBe[1].fr);
			A[2] = ori.getOCFromWC(A[0]);
			ori.rotate(VP);
			A[2] = ori.getWCFromOC(A[2]);


			if ((A[2] - A[1]) * ~(A[1] - A[0]) > 0)
			{
				// den kan antas rotera kring vertexen.
				return VERTEX_CENTERED;
			} else 
				return 1;
		}
			
			// kolla om det är en face-centered face
		if (pfxDiff.size() == 1 && pfxDiff[0] == FP)
		{
			cout << "   *******    \n Det is en FP rotation detta :) " << endl;
			
			
				//kontrollera så att inga punkter existerar i det området
			if (facePointActive)
				return 1;

			VEC A[3];
			Orientation ori(pat);
			A[2] = ori.getOCFromWC(faceCenteredPoint);

			ori.rotate(E_ToBe[0].fr.Pfx);
			A[0] = getWcFromPoint(E_ToBe[0].fr);
			A[1] = getWcFromPoint(E_ToBe[siz-1].fr);
			A[2] = ori.getWCFromOC(A[2]);

			list<Point> enclosedPoints;
			getEnclosedPoints(A, enclosedPoints);

			cout << "the following killar ligger in the way: " << endl;
			for (list<Point>::iterator itP = enclosedPoints.begin(); itP != enclosedPoints.end(); itP++){
				itP->print();
				cout << endl;
			}

				// Det är ingen vertexcentered face för den har punkter inom sig.
			if (enclosedPoints.size() > 0)
				return 1;


				// kontrollera 
			if (siz == 2)
				return FACE_CENTERED;

			cout << "kom hit" << endl;


			// Kontrollera så att polygonen är konvex om 
			// den är sluten.

				// här kan man vara ute på riktigt hal is om 
				// man exempelvis INTE bygger 10 edgeiga faces
				// i ikosaeder-symmetri, utan istället bygger
				// snorspetsiga fula trianglar. Men skyll dig själv!
			A[0] = getWcFromPoint(E_ToBe[1].fr);
			A[2] = ori.getOCFromWC(A[0]);
			ori.rotate(FP);
			A[2] = ori.getWCFromOC(A[2]);

			if ((A[2] - A[1]) * ~(A[1] - A[0]) > 0)
			{
				// den kan antas rotera kring vertexen.
				return FACE_CENTERED;
			} else 
				return 1;
		}

			// kolla om det är en edge-centered face
		if (pfxDiff.size() == 2 && ((pfxDiff[0]^pfxDiff[1]) == 6))
		{
			cout << "   *******    \n Det is en FN rotation detta :) " << endl;
			cout << "   *******    \n Det is en edge-centered kille om inga i vägen :) " << endl;
			
			
				//kontrollera så att inga punkter existerar i det området
			if (edgePointActive) {
				cout << "exit, edge-point is active" << endl;
				return 1;
			}


				// om det är ett rakt streck ?
			if (siz == 2)
				return 1;



			VEC A[3];
			Orientation ori(pat);
			ori.rotate(E_ToBe[0].fr.Pfx);

			switch(pfxDiff[0])
			{
				case FP:
				case VN:
					//A[0] = ori.getWCFromOC(VEC(COS30, -SIN30)*.5);
					A[0] = getWcFromPoint(E_ToBe[0].fr);
					break;
				case FN:
				case VP:
					//A[0] = ori.getWCFromOC(VEC(COS30, SIN30)*.5);
					A[0] = getWcFromPoint(E_ToBe[0].fr);
					break;
				default:
					cout << "hit ska jag typ icke kommmmma" << endl;
					break;
			}

			list<Point> enclosedPoints;

			for (int k=1; k<siz-1; k++)
			{
				A[1] = getWcFromPoint(E_ToBe[k].fr);
				A[2] = getWcFromPoint(E_ToBe[k+1].fr);
				cout << "\t ************ k=" << k << endl;

				cout << "E_tobe[" << 0 << "] = " << A[0] << endl;
				cout << "E_tobe[" << k << "] = " << A[1] << endl;
				cout << "E_tobe[" << (k+1) << "] = " << A[2] << endl;

				getEnclosedPoints(A, enclosedPoints);
			}


			cout << "the following killar ligger in the way: " << endl;
			for (list<Point>::iterator itP = enclosedPoints.begin(); itP != enclosedPoints.end(); itP++){
				itP->print();
				cout << endl;
			}

				// Det är ingen vertexcentered face för den har punkter inom sig.
			if (enclosedPoints.size() > 0) {
				cout << "Det is killar in the way" << endl;
				return 0;
			}

				// nästa punkt i serien kommer bli A[]
			A[0] = A[0]*2.0 - getWcFromPoint(E_ToBe[1].fr);


			cout << "kille0: " << A[0] << endl;
			cout << "kille1: " << A[1] << endl;
			cout << "kille2: " << A[2] << endl;
			
			cout << "value: " << ((A[0] - A[2]) * ~(A[2] - A[1])) << endl;

			if ((A[0] - A[2]) * ~(A[2] - A[1]) < 0)
				return 1;

			return EDGE_CENTERED;
		}
	}

		// allt funkar och den är inte sluten. Fortsätt bygga din fejja!!!
	return 1;
}
Exemple #5
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

	 * */


}
Exemple #6
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);
}