flashpixx

Du klammerst dich extrem an den Versuch ein perfektes Modell zu finden. Wenn jemand zwischen den beiden Bildern gegen das Stativ tritt oder sich die Luftschichtung ändert, dann verschiebt und verformt sich das Bild auf unbekannte Weise. Das lässt sich einfach nicht mit endlichem Aufwand bestimmen! Aus diesem Grunde reicht mir eine Näherung mit z.B. einem Polynom (oder etwas, was lokal arbeitet).

In diesem Fall reicht ein Polynom nicht aus, denn das "gegen das Stativ treten" ist, letztendlich eine zufällig Veränderung, die Du gar nicht beschreiben kannst, da Du sie nicht kennst. Ein Polynom wird dieser Beschreibung sicher nicht gerecht, denn gerade so etwas ist nicht polynomiell, evtl würde man so etwas wie Schwingung annehmen, aber das ist sicherlich nicht generalisierbar.

Als Beispiel: Man nimmt folgende äquidistante Wertereihe: 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

Fast jeder Weichzeichnungsfilter würde diese Reihe auf sich selbst abbilden. Egal woher die Messwerte stammen und welches physikalische Modell sich dahinter verbirgt.

Folgende ungleich verteilte Messreihe: 1, 2, 3, _, _, _, 7, _, _, _, 11, _, _, _, 15, ...

würde den dichter besetzten Stellen (1, 2, 3) mehr Gewicht verleihen als den dünner besetzten. Dennoch stellt diese Messreihe weiterhin einen linearen Anstieg dar und lässt in meinen Augen keine andere Interpretation zu.

Du kannst anhand der Eingabedaten Deine Verteilungsfunktion im Grunde frei nach Belieben anpassen, Du musst ja auch nicht zwingend was kontinuierliches nehmen, es geht ja auch z.B. etwas unstetiges (Treppenfunktionen) etc. Das liegt ja letztendlich in Deinem Ermessen. Du kannst auch nicht bekannte Daten einfach entfernen und dann eben daraus wieder äquidistant gewichten.

Ich bin der Meinung, dass das was Du da vor hast, nicht gut funktioniert.

Wie kann man einen Weichzeichner/Tiefpass implementieren, der beispielsweise diese Messreihe korrekt auf sich selbst abbildet (und indirekt damit auch die Lücken füllen kann)?

Was soll das nutzen, ein "Filter" der die Daten auf sich selbst abbildet ist letztendlich eine Identitätsabbildung Identische Abbildung

Aber das ist doch nicht der Sinn eines Filters. Vor allem muss Dir die Frequenz, nach der Du Filter willst bekannt sein, woher nimmst Du diese?

Bei aller Liebe zur Theorie: es muss auch realisierbar sein. Wenn ich meine Musik auf einen Hoch- und einen Tieftöner verteilen will, muss ich auch nicht das ganze Orchester physikalisch modellieren.

schau Dir z.B. mal Unabhängigkeitsanalyse an, das ist so etwas was Du suchst. Die Prämisse, die man trifft ist, dass man eine Anzahl Signale hat und diese werden linear gemischt (das Problem auf einer Cocktailparty, mehrere Leute reden und Du hast in einer Tonaufnahme das Stimmengewirr oder Du würdest mehrere Photos mit dem gleichen Film machen, so dass sich die Bilder addieren / übereinander legen).

Wichtig hierbei ist, dass ich davon ausgehe, dass die Daten "linear" gemischt wurden. Nun möchten wir am liebsten wieder jedes Signal einzeln haben, d.h. wir müssen "irgendwie" das gemischte Signal auftrennen, d.h. wir brauche die inverse Mischabbildung.

Nun geht man mit einem Optimierungsverfahren an diese Fragestellung heran, d.h. man sagt, wenn die Signal linear gemischt wurden und ich sie optimal trennen könnte, dann würde ich nur noch Rauschen haben und genau dieses optimiert man nun, d.h. ich versuche eine Matrix (nämlich die Inverse zu meiner Mischfunktion) zu bestimmen, die dazu führt, dass ich nur noch Rauschen übrig habe. "Rauschen" kann ich über die Entropie messen, d.h. ich kann letztendlich numerisch optimieren wie "gut" meine Trennung ist, denn wenn sie gut ist, dann hab ich Gaußrauschen, d.h. keine Information mehr.

Du willst doch letztendlich auch nichts anderes machen, Du willst aus eine Abbildungfunktion finden, nur bei Dir ist die Problematik, dass Du eben überhaupt keine Informationen hast, wie das Signal aus Bild 1 sich zum Bild 2 verändert, d.h. ich würde daran anknüpfen, dass ich versuche bekannte Strukturen in den Bildern erst mit einer möglichst hohen Sicherheit zu finden (z.B. gleiche Sternkonstellationen) oder eben gleiche Planeten. Dies kann ich z.B. durch Mustererkennung erreichen oder ich berechne die Planetenbahn und schau ob im zweiten Bild mit einem gewissen Epsilon der Planet gefunden wird.

Die nächste Frage ist, ob man hier eine globale Abbildungsfunktion finden kann oder ob man lieber die Bilder in Teilstücke zerlegt und lieber mehrere Abbildungsfunktionen erzeugt und ggf diese später zusammen fasst.

Wenn ich nun weiss wo aus Bild 1 ein Stern (bzw. ein Bereich) in Bild 2 zu finden ist, dann kann ich überlegen wie ich nun eine Funktion finden kann, die eben Bild 1 in 2 bzw invertiert 2 in 1 überführen kann. Kannst Du nun eine globale Funktion bestimmen, dann wäre dies Deine gesuchte Abbildungsfunktion. Ich würde aber hier definitiv wohl eher lokal arbeiten und dann ggf stückweise die globale Funktion erzeugen.

So wie ich Dein Problem verstehe, willst Du doch nicht glätten, denn das geht mit einem Gauß- oder Rangordnungsfilter, sondern Du willst wissen "wie" sich Deine Daten verändert haben, Deine Fragestellung ist dann doch letztendlich eine andere. Rauschen sollte mit so einem Filter kein großes Problem sein, aber der Tritt gegen das Stativ oder z.B. Rauch aus einer Zigarette schon, der vor die Linse geblasen wird. Wenn Du die Abbildungsfunktionen zwischen zwei Bildern bestimmen kannst, dann wirst Du aus einer Reihe von mehreren Bildern auch die "technischen Besonderheiten" bestimmen können. Denn wenn z.B. die Linse eine Eigenschaft hat, dann müssten Deine Abbildungsfunktionen Ähnlichkeiten aufweisen, d.h. Du wirst mit der Zeit die Eigenheiten der Technik erkennen können.

Ich würde hier zu einer Mehrschichtarchitektur & Mandenbasiertem WWS tendieren. Jeder Mandant entspricht einem Shop (mit eigenem Login) im WWS gibt es dann Produkte die entweder Mandantenspezifisch sind (sie existieren nur innerhalb des Mandanten) und es gibt Produkte die für alle Mandanten existieren (somit "global" sind).

Die Anbindung der Shops geschieht nicht über das Backend, das ist aus bezüglich der Architektur extrem schlecht, denn änderst Du das Backend müssen automatisch alle Shops angepasst werden. Schaffe eine abstrakte Kommunikationsebene zwischen Shop und Anwendungsserver (z.B. via Webservice). Der Anwendungsserver greift alleine auf die Datenbank zu.

Zusätzlich kann jeder Shop lokal ggf Produkte anpassen, d.h. Du kannst ein globales Produkt für einen speziellen Shop anpassen, diese Informationen sind dann mit dem Produkt aus dem WWS verknüpft werden aber in der lokalen Datenbank des Shops gepflegt.

So wie Deine Graphik das zeigt würde ich davon abraten, Du hast hast die Problematik bei Anpassungen und zusätzlich ist die Skalierfähigkeit recht eingeschränkt, da Du direkt an der Datenbank hängst. Zusätzlich stellt sich dabei auch die Frage der Zugriffe (wer hat welche Recht). In Deinem Fall sind die WWS Authentifizierung zu den Shop Logindaten, d.h. wird ein Shop kompromittiert komme ich auch in Dein WWS.

[...]dir einmal auf dem monitor und in eine access-db schreibt. dann hast du innerhalb kürzester zeit alle relevanten daten und nach einiger zeit hast du auch immer ne ziemlich aktuelle db mit den nutzerdaten, die sich regelmäßig wie von zauberhand aktualisiert....

Kannst Du mal erklären, warum Du den Datenstand aus dem AD in eine Accessdatenbank duplizieren willst? Du erzeugst damit redundante Informationen, die sicherlich niemals so aktuell sind, wie die Daten im AD, dazu kommt Pflegeaufwand. Das ist weder fachlich noch wirtschaftlich sinnvoll, das AD ist die Datenbank in der alle Informationen vorhanden sind, d.h. dort muss man sie nur lesen.

@ flashpixx:

ja, ist bekannt. Aber wenn er schon das Senden von Mail für aufwendig und untransparent hält ... dann würde ich eine pgp-ähnliche Zwischenschicht nicht unmittelbar voraussetzen.

Naja das kann man auch automatisiert machen, wäre jedenfalls technisch möglich, dass z.B. der MTA bevor er die Mail an den anderen MTA überträgt das signiert und verschlüsselt.

Was mir mehr fehlt ist eine Verschlüsselung ... ich sehe Internet immer noch als Hort des Bösen an :-)

S/MIME

PGP/MIME

Wofür soll ich die Planetenbahnen berechnen? [...]

Aber das reicht nicht: Temperaturschwankungen in der Atmosphäre verursachen unberechenbare Lichtbrechung, der sog. "Spiegelschlag" bei Spiegelreflexkameras kann der sog. Spiegelschlag zwischen den einzelnen Bildern Verschiebungen verursachen, die chromatische Aberration und ungewünschte Linsenverzeichnung verzerren das Bild weiter, etc. pp.

Ich wiederhole mich, Du gehst von Deinen gemessenen Daten aus. Wenn ich Dir zwei Datensätze gebe, einmal einen numerisch berechneten, der die physikalischen Eigenschaften abbildet und auf diesen füge ich ein Rauschen hinzu und ich gebe Dir einen original empirisch gemessenen Datensatz, dann kannst Du nicht entscheiden, welcher Datensatz welcher ist.

Ich muss auch nicht die Bahnen selbst bestimmen, sondern deren erste Ableitung an vorgegebenen Stellen im Bild.

Die Ableitung eines Bildes lässt sich direkt bestimmen, es ist die Differenz zweier Punkte. Wo ist das Problem?

Eingabe war die Bildposition, Ausgabe war der Bewegungsvektor an dieser Stelle.

Wie kannst Du aus 2 diskreten 2D Werten einen Bewegungsvektor bestimmen, das geht mathematisch nicht, denn eine Bewegung ist nach Definition die Lösung der Bahngleichung ( Bewegungsgleichung ), 2 Pixel sind keine Bahn / Trajektion. Du bekommst aus Deinem Bild nicht mehr als einen Farbwert an einer Position. Ein Bewegungsvektor hat eine Richtung und eine Länge (Beschleunigung).

Bereits mit einem Polynom 1. Grades (nur affine Abbildung) sollte sich eine Abbildung auf einer elliptischen Bahn darstellen lassen.

Ich gehe davon aus, dass Du auf Elliptische Kurve . Du solltest eine Elliptische Kurve nicht mit einer "geometrischen Kurve" verwechseln. Die Elliptische Kurve ist eine algebraische Struktur, Du suchst aber eine Ellipse (siehe dazu auch Geometrie )

Du wirst mit einem Polynom keine Planetenbahn oder selbst einzelne diskrete Stellen der Bahn hinreichend genau bestimmen können. Du schreibst oben, dass Du die erste Ableitung der Bahn benötigst, Du hast aber aktuell keine Bahn und nach Deiner Schilderung brauchst Du sie auch nicht, wie willst Du dann die Ableitung bestimmen? Wenn Du die Ableitung zwischen diskreten Punkten bestimmen willst, dann ist es nur die Differenz, wenn Du die Ableitung der Bahn brauchst, dann brauchst Du die Bahnfunktion. Deine Aussage ist somit nicht korrekt.

Ich wollte mich nochmal in NURBS einlesen - ggf. lässt sich damit was machen.

NURBS = Non-rational B-Splines sind auch nicht's anderes als stückweise zusammengesetzte Polynome, bei mehrdimensionalen Strukturen wird eben über mehrere Splines einfach ein Tensorprodukt gebildet. Was sollen Dir NURBS für Deine Problemlösung bringen, es sind letztendlich auch nur Polynome, damit bleibt das Problem bestehen.

In Anlehnung an Dein anderes Post ist mir nicht klar, was überhaupt der Sinn von dieser Aufgabenstellung ist. Wenn Du nach Sternbildern in den Bildern suchen willst, dann trainiere sie z.B. mit einem neuronalen Netz und speichere das Netz. Nun kannst Du neu gemacht Bilder nehmen und das Netz kann Dir sagen, welche Sternbilder in dem Bild vorhanden sind. Extrahiere die Sternbilder in hinreichend guter Qualität und trainiere das Netz. Ein NN liefert bei entsprechend gutem Training auch bei verrauschten Daten noch gute Ergebnisse.

Wenn Du die Bahnbewegung herleiten willst, dann ist es im Grunde unerheblich ob Du Messdaten hast oder nicht, denn die Bahn kannst Du numerisch via DGL berechnen. Wenn Du nun diese gegen ein Bild prüfen willst, dann projeziere die berechnete Bahn in Abhängigkeit der Position des Beobachters in eine 2D Ebene. Diese berechneten Daten kannst Du dann z.B. via Netz in Deinen Bildern zuordnen. Über die Bahnfunktion kannst Du aber ebenso berechnen, wo sich ein Stern hinbewegen wird.

Warum klammerst Du Dich so extrem an Deine Messdaten? Du versuchst ein "Modell" aus Deinen Daten zu generieren, wobei Du nur einen minimalen Ausschnitt des Datenraums betrachtest, d.h. Dein Modell kann gar nicht generalisieren, weil Dir zig Informationen fehlen. Warum gehst Du nicht von dem Modell aus und fittest das Modell aufgrund der Daten, das ist ein deutlich einfacherer Weg, weil das Modell das Problem vollständig beschreibt und dann nur mit empirischen Daten gefüttert werden muss. Wenn Du nur wenige Datensätze hast und diese noch einen hohen Rauschanteil haben, wirst Du daraus nicht mehr Informationen generieren können. Wenn Du aber das Modell kennst, dann kannst Du anhand des Modells aber das Rauschen sehr schnell erkennen und entfernen.

Die Gleichung für die Bewegung der Planeten ist die Kepler-Gleichung (weiteres Planetenbahn, wo genau der Hinweis auf numerische Integration gegeben ist, um die Bahn zu bestimmen)

Es werden 10 neue Rechner ausgeliefert. Da bei uns über RADIUS Internet authentifiziert wird, müssen Benutzer und Computer in eine spezielle Gruppe im AD aufgenommen werden. Nun ist aber Computername unbekannt und der Benutzer nutzt bereits diesen PC. Da ist es halt Sinnvoll Manfred Müller (z.B.) unter Namen einzugeben und ich erhalte Computername, IP und Softwareliste.

Das kann nicht sein, sobald der Rechner teil einer Domäne ist, muss dessen Name bekannt sein und es muss ein entsprechender Account in der Domäne existieren. Für einen Zugang zum INet authentifziert man eigentlich nicht den Rechner, sondern den User und der ist unabhängig vom Rechner.

Wenn Du das Login kennst, dann weisst Du auch wo der User überall angemeldet ist.

Ein weiterer Punkt ist, dass Rechner häufig die Standorte wechseln. Wir sind ein Unternehmen was Standortübergreifend arbeitet.

Es geht halt in erster Linie Informationen schnellstmöglich über Benutzer in Verbindung zum Client zu bekommen!

Wo ist das Problem? Ein Rechner wird nicht so ohne weiteres von Standort A zu B umziehen ohne dass die IT dies mitbekommt. Im Normalfall ist dies technisch gar nicht möglich (Portsecurity auf den Switches).

Du bekommst alle Infos, sowohl zu Usern wie auch Rechner aus der zentralen Datenbank (AD), ich sehe da beim besten Willen kein Problem. Wo siehst Du eins?

Ich denke das kommt etwas auf Eure Infrastruktur an, aber wenn man alle Informationen zu einem User z.B. im AD / LDAP hat (Telefon, Name etc), dann kann man theoretisch wenn man VoIP einsetzt schon beim Anruf des Users die passenden Informationen holen und anzeigen lassen bzw. der Login + Domäne ist ebenso eindeutig.

Ich würde wirklich dazu raten, dass man einmal eine zentrale Datenbank hat und dort alle Infos ablegt, gegen diese authentifziert und auch die Informationen dort passend aktuell hält. Anhand des Logins sollte es ebenso möglich sein heraus zu bekommen, wo sich der User an welchem System überall angemeldet hat ( Kerberos (Informatik) sollte diese Informationen vorhalten).

Das Speichern in Dateien finde ich irgendwie 80er Stil und völlig ineffizient, denn man hat doch eine zentrale Datenbank, warum dann zusätzlich noch diverse Dateien. Ich muss eigentlich nur die Datenbank abfragen und eben dafür sorge tragen, dass die ordentlich gewartet wird.

Wofür steht DGL?

Differentialgleichung

um Hintergrund: [...]

Ich kenne den anderen Thread, da hatte ich ja Dir ja auch schon mal was geschrieben : http://www.fachinformatiker.de/algorithmik/155422-physikalisches-modell-gummiebene.html

Die Bahnen der Sterne sind nicht sonderlich komplex. Ich einem früheren Versuch hatte ich einen Polynom 4. Grades als Ausgleichsfunktion verwendet, was nicht ausreichend gut konvergierte (simulierte Abkühlung). Ich denke, ich werde das nochmal versuchen.

Eine SA geht nur dann, sofern Du die Funktion kennst, das wird wohl hier nicht der Fall sein, denn Du suchst ja eine Funktion f, die den Punkt s (Stern) auf einen Punkt t abbildet, d.h. ja zwischen zwei gemessenen Datenpunkten eine Abbildung beschreibt. Du willst also hier eine Abbildungsfunktion bestimmen. Ein Polynom wird definitiv nicht funktionieren, denn Planetenbahnen sind elliptisch, d.h. der Beobachter projeziert die in 3D sichtbare Bahn auf eine 2D Fläche (Photo), eine elliptische Bahn enthält trigonometrische

Funktionen, die sich nicht durch ein Polynom approximieren lassen, d.h. das wird meist schlecht funktionieren.

SA wiederum benötigt irgendeine Funktion als Basis, die in das Verfahren gegeben wird, SA macht letztendlich auch nur eine Suche nach einem Minimum (und das eben heuritisch), d.h. Du brauchst als Basis eine Funktion, auf der Du suchen kannst, diese kennst Du aber hier nicht.

Planetenbahnen lassen sich eben als DGLs beschreiben (eher als DGL-System), da ja jeder Planet mit anderen in Wechselwirkung besteht (Massenbeziehung). Diese DGL kannst Du recht allgemein formulieren, d.h. Du beschreibst eine DGL eines Planeten in Abhängigkeit seiner Nachbarn, damit kannst Du erst einmal abstrakt dessen Bahn berechnen und eben auf Deinem Bild in 2D projezieren (ich empfehle die Berechnung in 3D und dann darauf aufsetzend die Projektion nach 2D). Diese DGL kannst Du mit Hilfe der FEM / ODE-Solver lösen und Dir somit die disketisierte Bahn erzeugen. Du wirst aber wahrscheinlich gar nicht präzise alle Informationen für die Bahnberechnung haben, d.h. Du wirst einige Unbekannte haben, diese Unbekannten kannst Du dann aber anhand Deiner Messdaten z.B. mit SA fitten, d.h. Du löst numerisch die DGL für die Bahnberechnung und setzt zufällig die unbekannten Parameter. Nach dem Lösen vergleichst Du das Ergebnis der Bahn mit Deinen realen Messdaten und versuchst den Fehler zwischen Messdaten und numerischer Lösung durch Veränderung der unbekannten Parameter zu minimieren.

Du hängst Dich sehr an Deine gemessenen Daten, der Ansatz ist hier eher suboptimal, weil Du versuchst eine Funktion zu raten. Gehe von der Physik aus, Planetenbewegungen unterliegen Gesetzen, diese kann man durch eine DGL beschreiben, Du musst dann "nur noch" die Parameter, die sich z.B. durch Messungenauigkeiten ergeben, der DGL bestimmen und dies geht mit Hilfe eines Minimierungsverfahrens. Sprich Du löst die DGL n-fach (für einen Planeten) und optimierst die Parameter der DGL (lässt sich sehr gute parallelisieren und DGL Solver können via Cuda / OpenCL arbeiten, d.h. sehr effizient).

Geh bei der Beschreibung des Problems nicht von den Daten aus, denn Deine Daten werden niemals hinreichend gut sein, sondern geh von dem physikalischen Modell aus und fitte / optimiere das Modell anhand der Daten, das wird definitiv bessere Ergebnisse liefern

Das mit dem Fitten habe ich bereits versucht, die von mir gewählte Funktion ließ sich aber nicht ausreichend anpassen. Eine Polynominterpolation hatte ich schonmal versucht, aber nicht richtig hinbekommen (zu langsame und zu schlechte Konvergenz).

Das muss definitiv an der Implementation bei Dir liegen, Polynominterpolation ist extrem effizient, wenn man es richtig macht.

Glattheitsanforderung ... ich denke die 2. Ableitung reicht, die 3. Ableitung wäre optimal.

dann brauchst Du mindestens Sobolev-Raum oder sogar Lp-Raum

Das Rauschen folgt keinem mir bekannten Muster.

Es geht nicht darum, ob Du ein Muster erkennst, sondern es geht darum, dass in realen Daten immer ein Rauschen vorhanden ist. Man kann anhand der technischen Erfassung der Daten auf das Rauschen schließen.

Aus dem Bauch heraus hätte ich jetzt einfach eine Gauss-Glocke über das Feld geschoben und jeden Messwert duch das gewichtete Mittel ersetzt - aber beim zweiten Blick ist mir aufgefallen, dass das nur bei äquidistanten Messwerten funktioniert.

Nein, nicht zwingend, Du musst letztendlich die Gaußfunktion anpassen.

Ich habe jetzt eine Lösung implementiert, die grundsätzlich zu funktionieren scheint und brauchbare Ergebnisse liefert: zusätzlich zum obigen Algorithmus wird jeder Messwert umgekehrt proportional zur Messwertdichte seiner Umgebung gewichtet. Ich denke, dass das seinen Zweck erfüllt, aber eine "übliche" Lösung wäre mir lieber.

Du hast die Frage, was gegeben ist nicht wirklich beantwortet. Aufgrund einer Bewegungsgleichung kannst Du die DGL bestimmen und mit Hilfe einer FEM o.ä. lösen lassen, wenn die DGL unbekannte Parameter enthält, die durch die Messwerte bestimmbar sind, dann kannst Du durch ein Fehlerminimierungsverfahren die DGL Parameter an Deine Messdaten anpassen. Eine FEM liefert eine Lösung mit hinreichenden Glätteanforderungen.

Du wirst ohne Kenntnisse, wie die Daten strukturiert sind, immer den Fall haben, dass Dein Verfahren schlechte Ergebnisse liefern wird, weil es für Dich nicht entscheidbar ist, wann ein Messwert ein statistischer Ausreißer ist und wann er ein ein korrekt erhobener Messwert ist.

Das Verfahren was Du jetzt hast wird im Fall von sehr wenigen Messwerten starke Ausreißer erlauben, d.h. Du wirst an den Kanten extreme Verzerrung der Gewichtung haben, sprich wenn die Dichte sich sehr abrupt ändert, dann "mittelst" Du letztendlich.

Es kommt drauf an, wie die Daten strukturiert sind. Man kann eine Polynominterpolation machen oder man die Daten anhand einer Funktion fitten, wobei man eben dann die Ausreißer durch eine Fehlerfunktion korrigiert. Zusätzlich wäre es wichtig zu wissen, welche Glattheitsanforderungen (z.B. L2-Räume) gefordert sind. Ebenso ist es wichtig zu wissen wie die Daten gesamplet wurden (äquidistant oder nicht). Je nach Daten und Rauschen kann man auch einen Filter (z.B. Hoch- / Tief- / Kammfilter ) die Daten filtern.

Generell gilt, dass Du wissen musst, wie das Rauschen entstanden ist, folgt es einem Muster oder nicht bzw. wozu die Daten später verwendet werden bzw- was an weiteren Informationen zu den Daten gegeben ist

@Brixto: siehe mein Post bezüglich SSI

Von PHP kommt kein Fehler, benutze zum Debuggen die PHP Console für den Google Chrome

Das erfordert aber Anpassung der PHP Scripte, denn PHP kann nicht im Browser debuggen, das ist technisch nicht möglich, da die Scripte serverseitig durch deren PHP Interpreter, der im Webserver eingebunden ist, aufgerufen werden.

Um das, was der OP machen will, durchzuführen braucht man man Server Side Includes die müssen im Webserver korrekt installiert und konfiguriert sein. Hat man das nicht, geht es nicht.

Hat man keine SSI, dann generiert man eben den kompletten Seitencode per PHP und gibt ihn via echo aus.

Ich weiß aber trotzdem leider nicht, wie ich das schreiben muss.

Warum liest Du Dir nicht mal die Doku zu der verwendeten Komponente durch, da steht das nämlich drin: JOptionPane (Java 2 Platform SE v1.4.2)

Am ende des skriptes überprüfe ich jetzt imm ob date +%H%M%S > 4 Uhr ist wenn ja wird eine email verschickt.

Wieso sollte das nicht gehen?

Es geht um die Prüfung auf == bzw >, das ist ein Unterschied.

Wenn ich einen zeitgesteuerten Job brauche, dann lege ich dafür einen Eintrag in der Crontab, da ich ja weiß wann dieser Job läuft brauche ich die Prüfung nicht

Zusätzlich würde ich die Prüfung nicht durchführen, denn es wird bei einem theoretischen manuellen Start kaum möglich sein, exakt 4 Uhr zu treffen, d.h. Du wirst immer eine gewisse Zeitspanne prüfen müssen, aber wer startet schon manuell nachts um 4 Uhr ein Script!?

Wäre durchaus möglich, theoretisch kann man aber auch ein 3D Game machen, denn OSM liefert ja auch Gebäudetypen etc. d.h. man könnte immer den Ausschnitt der Straße in dem man sich befindet real in 3D z.B. via Irrlicht Engine - A free open source 3D engine rendern, d.h. durch die Straßen kann ich dann laufen und wenn ich eben schneller voran kommen will, nehm ich halt andere Verkehrsmittel (wenn man dann möchte kann man ja auch ein bisschen in die Ego-Shooter-Perspektive gehen). Für die Benutzung der Verkehrsmittel muss man Geld bezahlen, wobei man das ja dann wieder daran koppeln kann, dass man Sachen für Leute transportieren muss, bzw. irgendwelche Subchallenges hat.

Zusätzlich kann man ja auch ein Kommunikationssystem (a.k. Telefon) erstellen, so dass man sich zum Telefonieren treffen kann (was dann einen Chat ermöglicht).

Nimmt man als Grundlage nicht eine Stadt, sondern z.B. die komplette Weltkarte und dazu dann mehrere Jäger und mehrere gejagte, dann ist das durchaus interessant, wenn man dann auch z.B. die Reisezeit entsprechend berechnet.

Für die Gejagten kann man ja dann auch noch diverse Möglichkeiten einbauen, wie sie sich z.B. verstecken können.

Ich denke da so in die Richtung Agentenspiel.

Rundenbasiertes Spiel halte ich für irgendwie nicht so schön, annähernd Echtzeit fände ich viel interessanter.

Was mir dazu noch einfällt ist, dass Du Dir das Spiel sogar mit realen Daten erzeugen kannst DE:Öffentlicher Verkehr - OpenStreetMap Wiki bzw http://wiki.openstreetmap.org/wiki/DE:%C3%96pnvkarte

Ich denke die Problematik, die Du hier ansprichst, ist für andere interessant, darum führe ich das etwas aus:

Wir nehmen einmal Deine XML, in der wir das Straßennetz abspeichern. Du hast dann ein Problem, dass Du in der XML Stationen erzeugen kannst, die nicht in Deinem Straßennetz vorhanden sind ( Erreichbarkeitsproblem in Graphen bzw Zusammenhang (Graphentheorie) ). Du musst also sicherstellen können, dass Dein Graph zusammenhängend ist, d.h. jeder Punkt erreichbar ist. Mit XML alleine ist das nicht machbar.

Das zweite Problem, was daraus resultiert, wäre, wenn Du einen gerichteten Graphen hast, d.h. Du kannst von einer Station nur in eine Richtung fahren, dann entsteht das Problem der Traps, d.h. ich kann an eine Station gelangen von der ich nicht mehr weg komme (Sackgasse). Dies solltest Du auch verhindern, wenn Du so etwas machst.

Als drittes eher praktisches Problem bei XML hast Du, dass Du in Deiner Node z.B. für Bus formal eintragen kannst, zu der keine Station existiert, d.h. Du musst also auch sicherstellen, dass Deine XML inhaltlich valide ist.

Als weiteres Problem bei XML ist, dass Du es parsen bzw. den gesamten Baum im Speicher halten musst. Damit hast Du aber das Problem der Referenzen zwischen Deinen XML Nodes und den Graphpunkten nicht gelöst, denn wenn ich auf einer XML Node stehe und ich weg will, muss ich die passende Zielnode beim Wechsel aus dem Speicher holen, sprich ich muss bei SaX den Parser anweisen "such mal die passende Node" (Aufwand).

Als nächstes ist dann noch die Frage, wie Du die Informationen an den Spieler hängst, denn ein Spieler muss ja wissen, auf welchem Feld er steht. Du musst also immer eine Referenz oder Kopie auf Deine XML an den Spieler hängen, so dass Du hier bei großen Straßennetze durchaus viel Speicheraufwand hast. Wenn ich da jetzt den Gedanken weiter spinne und z.B. das ganze über Netz auch spielen möchte, dann muss ich mir ja auch überlegen, wie ich das Straßennetz für alle Spieler gleich aussehen lasse, eine XML kann ich leicht per Hand verändern, so dass jeder Spieler sich lokal seine Karte verändern kann. Wenn ich dann noch zulasse, dass Spieler gleichzeitig ziehen können und die Karte z.B. über einen Webservice bereit stelle, dann habe ich 2 Anfragen der Spieler bei der für jeden Zugriff ein XML Prozess gestartet wird, der die XML parsen muss. Für große Anzahl an Spielern und große Karten, ist das nicht mehr praktikabel.

Auch bei mehreren Spielern pro PC, solltest Du Dir überlegen, wie Du diese XML Daten passend verarbeitest, denn Du hast nur die Möglichkeit den Baum einmal zu lesen, ein Baum ist aber kein Graph, d.h. Du brauchst noch irgendwie eine Transformation des Baumes in das Straßennetz oder Du musst das in "Echtzeit" machen, was durchaus auch nicht unkritisch ist.

Was man ja gerne hätte, ist, dass der Spieler weiß wo er steht, d.h. er hat irgendwie eine Position, diese Position verweist dann auf einen Knoten im Straßennetz. Ich kann den Knoten fragen "welche Verbindungen erlaubst Du wohin", ebenso kann ich die Person fragen "wo stehst Du gerade". Der Knoten wiederum braucht nicht das komplette Straßennetz speichern, er muss lediglich eine Liste mit Knoten speichern, auf die man sich bewegen kann, d.h. allerhöchstens eine Adjazenzliste. Rein technisch braucht er noch nicht mal das, denn bei sehr vielen Verkehrsmitteln und vielen Verbindungen wäre das durchaus Speicherbedarf der dann für alle Spieler anfällt. Er muss nur eine Referenz auf ein Graphdatenbankobjekt speichern, dass dann in Abhängigkeit von seiner aktuellen Position die Liste mit den Nachbarknoten liefert, d.h. die Adjazenzliste muss ich allenfalls temporär halten (diese Liste kann ich dann nochmals reduzieren, wenn ich z.B. die Abfrage so erstelle, dass ich das Verkehrsmittel vorgebe).

Zusätzlich kann ich damit auch ohne Probleme sehr große Netze mit sehr vielen unterschiedlichen Verkehrsverbindungen darstellen (z.B. Flugzeug, Bahn, U-Bahn, Bus, Taxi, zu Fuß), weiterhin kann ich auch gerichtete Graphen erzeugen, weil mir die Datenbank ggf abnehmen kann dafür zu sorgen, dass meine Knoten im Graphen immer erreichbar sind.

Graphstrukturen sollten immer sehr gut durchdacht werden, denn durch das quadratische Wachstum der Datenmenge kommt man sehr schnell an die physischen Grenzen seines Rechners, wenn man es naiv macht.

Die Funktion CryptDeriveKey sollte bei gleichem Passwort und gleichen verwendeten Algorithmen eigentlich auch einen identischen Schlüssel garantieren.

Ich habe mir jetzt nicht im Detail die API Funktionen angeschaut, aber ich gebe zu Bedenken, dass das durchaus nicht so sein muss, denn im Normalfall ist es üblich den Schlüssel in Abhängigkeit von einem Zufallszahlengenerator zu generieren, d.h. gleiches Passwort und gleiches Algorithmus liefern nicht zwingend den gleichen Schlüssel. Es sollte Angreifern möglichst schwer gemacht werden, aus teilweise bekannten Daten die Schlüssel ggf durch Brute-Force zu rekonstruieren. Schau über die genauere Generation der Schlüssel in die Doku Deiner API, da steht letztendlich auch drin, wie dies im Detail gemacht wird.

Daraus lese ich, dass wenn eine Klasse keinem Package zugewiesen wird keinen vollständigen Klassennamen hat.

Packages and the Java Namespace (Java in a Nutshell)

If no package directive appears in a file of Java code, all classes defined in that file are part of a default unnamed package. As we'll see in Chapter 3, "Object-Oriented Programming in Java", classes in the same package have special access to each other. Thus, except when you are writing simple example programs, you should always use the package directive to prevent access to your classes from totally unrelated classes that also just happen to be stored in the unnamed package.

Try-Catch löst das Problem nicht, sondern es fängt lediglich den Fehler ab, wie Du ihn behandelst ist eben dann Deine Sache und eine Index-Out-of-Bounce Exception sagt, dass Du auf ein Element zugreifst, dass nicht existiert.

Zu Deinem Code, Du allokierst so lange lFehler true ist immer ein neues Array, obwohl sich die Daten des Arrays nicht ändern, d.h. jedes Mal wird Speicher allokiert und ggf erst später durch den GC freigegeben, das ist absolut sinnfrei.

Zweitens wird eine Exception hier jedes Mal auftreten, denn Du greifst auf das 5. Element zu, aber die Indizierung eines Arrays beginnt bei null, also ist der Index den Du verwendest generell falsch.

wie ist der vollständige Klassenname von selbst geschriebenen Klassen?

Java-Syntax

das wirf gelegentlich die Exception

umgehbar mit try-catch-block und while schleife außenrum gelegt.

Also rein mathematisch kann keine Exception auftreten.

Und bei wiederholtem rechnen tritt auch keine mehr auf.

Frage: Ist das normal? Wie oft tritt das in der Praxis/Realität auf?

Wie auch schon in Deinen anderen Thread angemerkt, zeige Deinen realen Code, dann kann man dazu auch was sagen. Dein Pseudocode ist absolut unbrauchbar, um das Problem zu verdeutlichen.

Ebenso solltest Du Dir angewöhnen, dass Du auch die entsprechenden Meldungen angibst, die Dein Code produziert.

Ich gehe davon aus, dass Dein Code mehrere semantische Fehler enthält, die durch Deine exzessive Nutzung von mehreren 100 Threads noch die Probleme durch die Nebenläufigkeit verstärken. Ändere Deinen Code so ab, dass er das Problem sinnvoll mit resourcenschonenden Strukturen löst. Du kannst hier Hilfe bekommen, aber Du musst schon dazu Deinen Code und auch die genaue Problemstellung und vor allem das Ziel angeben. Das Problem wird nicht an Java oder Deinem Rechner liegen, das Problem ist Deine Programmierung.

Deine Postings beschreiben bisher im Grunde die Aussage "mein Code läuft nicht, aber ich will den nicht zeigen und den Algorithmus will ich auch nicht überarbeiten"