Make Sense of WP Query Functions

Posted: 27th März 2012 by xaedes in Wordpress
0

http://wordpress.stackexchange.com/a/1755/9518

wie man bereits vorhandenen php-code von git verwaltbar machen kann

Posted: 8th Dezember 2011 by xaedes in Allgemein
0

pdt eclipse

wurzelverzeichnis : verzeichnis das alle von git zu verwaltenden verzeichnisse/dateien enthält (evt auch zusätzliche)
wurzelverzeichnis backup
wurzelverzeichnis leeren
(leeres) git repo von bitbucket (oder andere) mit egit klonen und repo in wurzelverzeichnis anlegen
wurzelverzeichnis backup wieder einspielen
egit repo kontext menü öffnen -> import projects
wizards : use the new projects wizard
php project
projectname wie gewünscht
create project at existing location (from existing source) : wurzelverzeichnis angeben

nun ist das php projekt mit dem gitrepo verbunden

Ganzzahlknappsack mit Greedy nicht optimal

Posted: 10th April 2011 by xaedes in Studium
0

Beispiel warum Greedy mit Ganzzahliger Mitnahme von Gegenständen nicht optimal ist

Rucksackgröße 15

Obj Wert Gewicht rDB
A 8 4 2
B 5 3 1.67

Angenommen wir würde nur den Gegenstand mit besten rDB (relativer Deckungsbeitrag = Wert / Gewicht)
mitnehmen, bis kein Platz mehr da ist. Dann würde man 3 Stück A mitnehmen und hätte noch 1 Gewicht
im Rucksack frei, wo wir nichts mehr reinpacken könnten. Der Gesamtwert wäre somit 24.
Würde man (nicht greedy) stattdessen nur B einpacken, könnte man 5 Stück mitnehmen und hätte keinen Platz
mehr im Rucksack übrig. Der Gesamtwert wäre somit 25, was besser als 24 bei der Greedy Variante wär.

Greedy:

Obj Wert Gewicht rDB Stück übrig Gesamtwert
A 8 4 2 3 1 24

Nicht Greedy:

Obj Wert Gewicht rDB Stück übrig Gesamtwert
B 5 3 1.67 5 0 25

Illustrator

Posted: 19th März 2011 by xaedes in Grafik
1

Jetzt habe ich mal angefangen ein wenig mit Illustrator zu arbeiten. Leider ist der Weg von Inkscape zu Illustrator recht holprig. Inkscape finde ich einfach viel intuitiver. Muss man sich schon ganz schön verbiegen bei Illustrator^^
Da ich eine dt. Sprachversion von Illustrator benutze sind auch einige Befehle schwieriger zu finden. Aber dazu habe ich eine tolle Seite gefunden, die sämtliche Befehle vom deutschen ins englische und zurück übersetzt: http://vektorgarten.de/illu-menus.html

Zum Anfang habe ich mal zwei kleinere Tutorials durchgearbeitet:

Kombiniert sieht das dann so aus:

Auf in den Weltraum!

Posted: 18th März 2011 by xaedes in Grafik
0


Pinup Nachbau

Posted: 5th März 2011 by xaedes in Grafik
1

Habe heute mit Inkscape dieses wunderbare Pin-up Girl Bild nachgebaut:

sdsd
Mein Nachbau
Original

Heute mal etwas Flash

Posted: 3rd März 2011 by xaedes in Allgemein
0

http://www.kongregate.com/labs

Steuerung mit Pfeiltasten und Leertaste (vorher erst in Spiel klicken)

Schnittpunkt zweier Geraden

Posted: 6th Februar 2011 by xaedes in Kaufhausschlacht
0

Wollen wir den Schnittpunkt zweier Geraden bestimmen bestimmt setzen wir die beide Geradengleichungen gleich:
\overrightarrow{x_1} = \overrightarrow{s_1} + k \cdot \overrightarrow{v_1} \\ \overrightarrow{x_2} = \overrightarrow{s_2} + m \cdot \overrightarrow{v_2} \\ \\ \overrightarrow{x_1} = \overrightarrow{x_2} \\ \overrightarrow{s_1} + k \cdot \overrightarrow{v_1} = \overrightarrow{s_2} + m \cdot \overrightarrow{v_2} \\

Jetzt müssen wir nach k oder m umstellen und in die entsprechende Parametergleichung einsetzen um einen Schnittpunkt zu errechnen:
\overrightarrow{s_1} + k \cdot \overrightarrow{v_1} = \overrightarrow{s_2} + m \cdot \overrightarrow{v_2} \\ \overrightarrow{s_1}.x + k \cdot \overrightarrow{v_1}.x = \overrightarrow{s_2}.x + m \cdot \overrightarrow{v_2}.x \\

  1. Fall : \overrightarrow{v_1}.x \neq 0
    k = \frac{\overrightarrow{s_2}.x + m \cdot \overrightarrow{v_2}.x-\overrightarrow{s_1}.x}{\overrightarrow{v_1}.x} \\ \overrightarrow{s_1}.y + k \cdot \overrightarrow{v_1}.y = \overrightarrow{s_2}.y + m \cdot \overrightarrow{v_2}.y \\ \overrightarrow{s_1}.y + \frac{\overrightarrow{s_2}.x + m \cdot \overrightarrow{v_2}.x-\overrightarrow{s_1}.x}{\overrightarrow{v_1}.x} \cdot \overrightarrow{v_1}.y = \overrightarrow{s_2}.y + m \cdot \overrightarrow{v_2}.y \\ \overrightarrow{s_1}.y + \frac{(\overrightarrow{s_2}.x-\overrightarrow{s_1}.x) \cdot \overrightarrow{v_1}.y }{\overrightarrow{v_1}.x} + m \cdot \frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} = \overrightarrow{s_2}.y + m \cdot \overrightarrow{v_2}.y \\ m \cdot (\frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} - \overrightarrow{v_2}.y) = \overrightarrow{s_2}.y - \overrightarrow{s_1}.y - \frac{(\overrightarrow{s_2}.x-\overrightarrow{s_1}.x) \cdot \overrightarrow{v_1}.y }{\overrightarrow{v_1}.x}

    1. Fall : \frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} - \overrightarrow{v_2}.y \neq 0
      m = \frac{\overrightarrow{s_2}.y - \overrightarrow{s_1}.y - \frac{(\overrightarrow{s_2}.x-\overrightarrow{s_1}.x) \cdot \overrightarrow{v_1}.y }{\overrightarrow{v_1}.x}}{\frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} - \overrightarrow{v_2}.y} \\ \\ \overrightarrow{x_2} = \overrightarrow{s_2} + m \cdot \overrightarrow{v_2}\\
      Schnittpunkt x_2 berechnet.
    2. Fall : \frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} - \overrightarrow{v_2}.y = 0
      \frac{\overrightarrow{v_2}.x \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} = \overrightarrow{v_2}.y

      1. Fall: \overrightarrow{v_2}.x \neq 0
        \frac{ \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} = \frac{\overrightarrow{v_2}.y}{\overrightarrow{v_2}.x}
        Geraden 1 und 2 sind parallel, schneiden sich also nicht.
      2. Fall: \overrightarrow{v_2}.x = 0
        \frac{0 \cdot \overrightarrow{v_1}.y}{\overrightarrow{v_1}.x} = \overrightarrow{v_2}.y \\ \overrightarrow{v_2}.x = \overrightarrow{v_2}.y = 0
        Gerade 2 hat keine Richtung, Geraden schneiden sich also nicht.
  2. Fall : \overrightarrow{v_1}.x = 0
    \overrightarrow{s_1}.x + k \cdot 0 = \overrightarrow{s_2}.x + m \cdot \overrightarrow{v_2}.x \\ \overrightarrow{s_1}.x = \overrightarrow{s_2}.x + m \cdot \overrightarrow{v_2}.x \\

    1. Fall: \overrightarrow{v_2}.x \neq 0
      m=\frac{\overrightarrow{s_1}.x-\overrightarrow{s_2}.x}{\overrightarrow{v_2}.x} \\ \overrightarrow{x_2} = \overrightarrow{s_2} + m \cdot \overrightarrow{v_2}\\
      Schnittpunkt x_2 berechnet.
    2. Fall: \overrightarrow{v_2}.x = 0
      \overrightarrow{v_2}.y = \overrightarrow{v_1}.x = 0
      Gerade 1 und 2 sind parallel, schneiden sich also nicht.

Bewegung mit Kollisionserkennung Teil 3 – Demonstrationsprogramm

Posted: 6th Februar 2011 by xaedes in Kaufhausschlacht
0

Teil 1 – Einführung
Teil 2 – Kollision mit Gerade
Teil 2 – Kollision mit Gerade – Demoprogramm
Teil 3 – Kollision mit Strecke
Teil 3 – Kollision mit Strecke – Demoprogramm

Zur Demonstration der bisherigen Lösung habe ich ein kleines Programm geschrieben, in welchem man sich die berechnete Lösung für beliebe Ausgangssituationen anzeigen lassen kann. Man sieht, dass nicht wirklich vorhandene Kollisionen nun nicht mehr fälschlicherweise “korrigiert” werden.
Screenshot:

Bedienung :
Linke Maustaste, Drag&Drop : roter und schwarzer Kreis, Enden der schwarzen Linie
Rechte Maustaste, Drag&Drop : Bildschirmausschnitt
Mausrad : Zoomen

Ausprobieren: win-06.02.2011-21.09

Relevante Quellcodeausschnitte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

bool TestBoundedMovement::DoLineSegmentsIntersect( sf::Vector2f s1, sf::Vector2f e1, 
	sf::Vector2f s2, sf::Vector2f e2 )
{
	sf::Vector2f v1 = e1 - s1;
	sf::Vector2f v2 = e2 - s2;
	sf::Vector2f intersection;
	if ( LinesIntersection( s1, v1, s2, v2, intersection ) ) {
		float k = LineParam( s1, v1, intersection );
		float m = LineParam( s2, v2, intersection );
		if( ( m >= 0 ) && ( m <= 1 ) &&
			( k >= 0 ) && ( k <= 1 ) ) {
			return true;
		} else {
			return false;
		}
	}  else 
		return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

bool TestBoundedMovement::LinesIntersection( sf::Vector2f s1, sf::Vector2f v1, 
	sf::Vector2f s2, sf::Vector2f v2, sf::Vector2f &intersection )
{
	if( v1.x != 0 ) {
		float a = v2.x * v1.y / v1.x - v2.y;
		if( a != 0 ) {
			float m = ( s2.y - s1.y - ( s2.x - s1.x ) * v1.y / v1.x ) / a;
			intersection.x = s2.x + m * v2.x;
			intersection.y = s2.y + m * v2.y;
			return true;
		} else {
			return false;
		}
	} else {
		if ( v2.x != 0 ) {
			float m = ( s1.x - s2.x ) / v2.x;
			intersection.x = s2.x + m * v2.x;
			intersection.y = s2.y + m * v2.y;
			return true;
		} else {
			return false;
		}
	}
}
1
2
3
4
5
6
7
8
9
10

float TestBoundedMovement::LineParam( sf::Vector2f s, sf::Vector2f v, sf::Vector2f p )
{
	float k = 0;
	if( v.y != 0 ) {
		k = (p.y - s.y) / v.y;
	} else if ( v.x != 0 ) {
		k = (p.x - s.x) / v.x;
	}
	return k ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

void TestBoundedMovement::UpdateCorrectDest()
{
	sf::Vector2f s = myCircleStart.GetPosition();
	sf::Vector2f v = myVector;
	sf::Vector2f pl1 = myLineBound.GetP1();
	sf::Vector2f pl2 = myLineBound.GetP2();
 
	sf::Vector2f z = s + v;
 
	sf::Vector2f ng0;
	sf::Vector2f nh0;
	if ( MathUtils::VectorLen(v) == 0 ) {
		myCircleCorrectDest.SetPosition( z );
		return;
	}
	sf::Vector2f v0 = v / MathUtils::VectorLen(v);
 
	if ( MathUtils::ComputeNormal( pl1, pl2, ng0 ) &&
		 MathUtils::ComputeNormal( s, z, nh0 ) ) {
 
		float r = radius;
 
		if( ! DoLineSegmentsIntersect( s + nh0 * r, 
		                               z + v0 * r + nh0 * r, 
		                               pl1, pl2 ) &&
		    ! DoLineSegmentsIntersect( s - nh0 * r, 
		                               z + v0 * r - nh0 * r, 
		                               pl1, pl2 ) &&
		    ! DoLineSegmentsIntersect( z + v0 * r + nh0 * r, 
		                               z + v0 * r - nh0 * r, 
		                               pl1, pl2 )) {
			//Bewegungslinie und BoundLine überschneiden sich nicht,
			//also wird keine Kollisionserkennung vorgenommen,
			//also ist myCircleCorrectDest = myCircleDest
			myCircleCorrectDest.SetPosition( z );
			return;
		}
 
		if( MathUtils::DotProduct( v, ng0 ) > 0 ) {
			//Bewegungsvektor zeigt von BoundingLine weg,
			//also wird keine Kollisionserkennung vorgenommen,
			//also ist myCircleCorrectDest = myCircleDest
			myCircleCorrectDest.SetPosition( z );
			return;
		}
 
		if( MathUtils::DotProduct( s - pl2, ng0 ) < 0 ) {
			//Der Startpunkt liegt hinter der Line
			//also wird keine Kollisionserkennung vorgenommen,
			//also ist myCircleCorrectDest = myCircleDest
			myCircleCorrectDest.SetPosition( z );
			return;
		}
 
		float d = ( MathUtils::DotProduct( z - pl2, ng0 ) );
 
		if( d >= r ) {
			//Es findet gar keine Kollision statt
			//also ist myCircleCorrectDest = myCircleDest
			myCircleCorrectDest.SetPosition( z );
			return;
		}
 
		float cosAlpha = MathUtils::DotProduct( v, pl2 - pl1 ) / 
				( MathUtils::VectorLen( v ) *  
				  MathUtils::VectorLen( pl2 - pl1 ) );
 
 
		float sinAlpha = sqrt( 1 - cosAlpha * cosAlpha );
 
		if( sinAlpha != 0 ) {
			float x = ( r - d ) / sinAlpha;
 
			sf::Vector2f z2 = z - x * v0;
			myCircleCorrectDest.SetPosition( z2 );
		}
	} else {
		//Normale konnte nicht berechnet werden, 
		//also liegen pl1 und pl2 auf einem Punkt,
		//also ist BoundingLine nicht vorhanden,
		//also ist myCircleCorrectDest = myCircleDest
		myCircleCorrectDest.SetPosition( z );
	}
}

Bewegung mit Kollisionserkennung Teil 3

Posted: 6th Februar 2011 by xaedes in Kaufhausschlacht
0

Teil 1 – Einführung
Teil 2 – Kollision mit Gerade
Teil 2 – Kollision mit Gerade – Demoprogramm
Teil 3 – Kollision mit Strecke
Teil 3 – Kollision mit Strecke – Demoprogramm

Übersicht:

  1. Problem
  2. Lösungsansatz
  3. Die Lösung
  4. Geradenschnittpunkt
  5. Parametergleichung umgekehrt
  6. Ende und Demo


Das Problem

Beim Herumspielen mit dem Demoprogramm fällt schnell auf, was wir noch beachten müssen. Die Kollision wird selbst dann berechnet, wenn die Bewegung gänzlich außerhalb der Begrenzungskante verläuft, wie hier veranschaulicht:

Dabei wäre die unkorrigierte Zielposition die korrekte. Wir müssen also entscheiden, ob eine Bewegung eine Begrenzungskante berührt oder nicht.
Dazu könnten wir einfach den Schnittpunkt S_{g,h} der Geraden g und h bestimmen und überprüfen, ob dieser innerhalb der Strecke zwischen p_{L1} und p_{L2} liegt. Wenn nicht, wird keine Kollisionserkennung durchgeführt. Allerdings würde dann folgendes passieren:

Der Schnittpunkt S_{g,h} liegt außerhalb der Strecke zwischen p_{L1} und p_{L2} und eine Kollisionserkennung würde nicht durchgeführt werden.
Allerdings findet eine Kollision statt, wie der rote Kreis verdeutlicht.

Lösungsansatz

Dadurch dass wir nicht nur eine Kollision für einen Punkt sondern für Kreise berechnen wollen, müssen wir auch die äußeren Begrenzungslinien der Bewegung daraufhin überprüfen, ob die Bewegung mit der Begrenzungskante kollidiert:

Die Punkte A_1, B_1, A_2 und B_2 spannen ein Rechteck auf, welches die Bewegung vollständig erfasst. Jetzt muss überprüft werden ob einer der Schnittpunkte S_{g,h,1} und S_{g,h,2} zwischen p_{L1} und p_{L2} liegen. Zusätzlich kann es noch einen Schnittpunkt geben, der durch die Strecke B_1 , B_2 entsteht. Für diesen muss die Überprüfung auch durchgeführt werden.
Sollte das einer der Schnittpunkte zwischen p_{L1} und p_{L2} liegen, ist eine Kollision mit der Begrenzungskante eingetreten, die erkannt und korrigiert werden muss.

Die Lösung

Zuerst müssen allerdings die Punkte A_1, B_1, A_2 und B_2 berechnet werden. Das ist relativ einfach:
\overrightarrow{v_0} = \frac{\overrightarrow{v}}{|\overrightarrow{v}|} \\ \overrightarrow{A_1} = \overrightarrow{s} + \overrightarrow{n_{h,0}} \cdot r - \overrightarrow{v_0} \cdot r \\ \overrightarrow{A_2} = \overrightarrow{s} - \overrightarrow{n_{h,0}} \cdot r - \overrightarrow{v_0} \cdot r \\ \overrightarrow{B_1} = \overrightarrow{z} + \overrightarrow{n_{h,0}} \cdot r + \overrightarrow{v_0} \cdot r \\ \overrightarrow{B_2} = \overrightarrow{z} - \overrightarrow{n_{h,0}} \cdot r + \overrightarrow{v_0} \cdot r \\

Wie prüft man nun, ob zwei Strecken sich kreuzen? Erstmal sollte man überprüfen, ob sich die beiden Geraden die durch die beiden Strecken aufgespannt werden überschneiden. Sollte das der Fall sein kann man an Hand des Schnittpunktes, testen ob dieser innerhalb der beiden Strecken liegt.
Alle Punkte x auf einer Strecke zwischen s und e sind durch die Parametergleichung
\overrightarrow{x} = \overrightarrow{s} + k \cdot ( \overrightarrow{e} - \overrightarrow{s} ) \\ 0 \le k \le 1
bestimmt.
Haben wir den Schnittpunkt der beiden Geraden also erst einmal gefunden, müssen wir für diesen Punkt x nur noch den Parameter k für beide Strecken bestimmen. Liegen beide Parameter innerhalb des Intervals [0..1], so kreuzen sich die Strecken:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

bool TestBoundedMovement::DoLineSegmentsIntersect( sf::Vector2f s1, sf::Vector2f e1, 
	sf::Vector2f s2, sf::Vector2f e2 )
{
	sf::Vector2f v1 = e1 - s1;
	sf::Vector2f v2 = e2 - s2;
	sf::Vector2f intersection;
	if ( LinesIntersection( s1, v1, s2, v2, intersection ) ) {
		float k = LineParam( s1, v1, intersection );
		float m = LineParam( s2, v2, intersection );
		if( ( m >= 0 ) && ( m <= 1 ) &&
			( k >= 0 ) && ( k <= 1 ) ) {
			return true;
		} else {
			return false;
		}
	}  else 
		return false;
}


Geradenschnittpunkt

Die mathematischen Hintergründe für die Berechnung eines Geradenschnittpunktes sind hier zu finden : Schnittpunkt zweier Geraden

Daraus ergibt sich folgender Programmcode:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

bool TestBoundedMovement::LinesIntersection( sf::Vector2f s1, sf::Vector2f v1, 
	sf::Vector2f s2, sf::Vector2f v2, sf::Vector2f &intersection )
{
	if( v1.x != 0 ) {
		float a = v2.x * v1.y / v1.x - v2.y;
		if( a != 0 ) {
			float m = ( s2.y - s1.y - ( s2.x - s1.x ) * v1.y / v1.x ) / a;
			intersection.x = s2.x + m * v2.x;
			intersection.y = s2.y + m * v2.y;
			return true;
		} else {
			return false;
		}
	} else {
		if ( v2.x != 0 ) {
			float m = ( s1.x - s2.x ) / v2.x;
			intersection.x = s2.x + m * v2.x;
			intersection.y = s2.y + m * v2.y;
			return true;
		} else {
			return false;
		}
	}
}


Parametergleichung umgekehrt

Möchte man den Parameter aus der Parametergleichung eines Punktes auf einer Geraden berechnen, muss man diese nur umstellen. Auf Grund der Trivialität dieses Vorgangs lasse ich die mathematischen Hintergründe hier ganz außen vor. Folgender Quellcode ergibt sich:

1
2
3
4
5
6
7
8
9
10

float TestBoundedMovement::LineParam( sf::Vector2f s, sf::Vector2f v, sf::Vector2f p )
{
	float k = 0;
	if( v.y != 0 ) {
		k = (p.y - s.y) / v.y;
	} else if ( v.x != 0 ) {
		k = (p.x - s.x) / v.x;
	}
	return k ;
}


Ende und Demo

Nun muss nur noch die Überprüfung für die beiden Strecken eingebaut werden:

//...
if( ! DoLineSegmentsIntersect( s + nh0 * r, z + v0 * r + nh0 * r, pl1, pl2 ) &&
    ! DoLineSegmentsIntersect( s - nh0 * r, z + v0 * r - nh0 * r, pl1, pl2 ) &&
    ! DoLineSegmentsIntersect( z + v0 * r + nh0 * r, z + v0 * r - nh0 * r, pl1, pl2 )) {
	//Bewegungslinie und BoundLine überschneiden sich nicht,
	//also wird keine Kollisionserkennung vorgenommen,
	//also ist myCircleCorrectDest = myCircleDest
	myCircleCorrectDest.SetPosition( z );
	return;
}
//...

Dazu gibt es wieder ein Demonstrationsprogramm:
Demonstrationsprogramm zu diesem Teil

Older Entries