Um die Autovervollständigung auf für die OpenCv funktionen zu nutzen, muss man nur den OpenCv Inkludepath in die .pro Datei eintragen:
INCLUDEPATH += /usr/include/opencv
Einmal qmake ausführen und fertig :)
Um die Autovervollständigung auf für die OpenCv funktionen zu nutzen, muss man nur den OpenCv Inkludepath in die .pro Datei eintragen:
INCLUDEPATH += /usr/include/opencv
Einmal qmake ausführen und fertig :)
Ich weiss zwar nicht warum, aber so funktioniert es. Da spart man sich den doppel Pointer
blah *a = 0;
func(a);
void func(blah *&a) {
a = new blah;
}
Also, ein Pointer einer Funktion übergeben und erst in der Funktion Speicher reservieren. Der Pointer bleibt aber ausserhalb der Funktion nutzbar.
Hier gefunden http://www.wachtler.de/ck/8_4_Grunddatentypen.html
C erhält durch Zeigerarithmetik erst richtig Leben; die größere Effektivität von Programmen in C rührt zu einem großen Teil davon. Angenommen, eine Funktion soll ein Feld mit double-Elementen löschen, also alle Werte zu 0.0 setzen. Ein ehemaliger FORTRAN- oder Pascal-Programmierer würde die Funktion vielleicht so schreiben:
/* grloel.c 31. 7.95 kw
*/#include
void loesche_double( double feld[], size_t wieviele )
{
size_t i;for( i=0 ; i < wieviele ; i++ ) feld[i] = 0.0; } Das funktioniert natürlich, aber die Lösung enthält überflüssige Berechnungen. Abgesehen von der nötigen Erhöhung des Schleifenzählers (Auswertung von ++) muß bei jedem Durchlauf die Adresse des Elementes feld[i] berechnet werden. Dazu muß das Programm die Adresse hernehmen, die mit dem Namen feld verbunden ist (das ist die Adresse des ersten Feldelements), und dazu ein Produkt addieren, nämlich i*sizeof(double) (zur Auswertung von feld[i]). Mit Zeigerarithmetik läßt sich die Funktion wesentlich schneller machen: /* grloes.c 31. 7.95 kw */ #include
void loesche_double( double *feld, size_t wieviele )
{
double *pfeld = feld;
double *pende = feld+wieviele;while( pfeld < pende ) *pfeld++ = 0.0; } Jetzt wird der Parameter feld als Zeiger auf das erste Element aufgefaßt. Ein Zeiger (pfeld) wandert durch das Feld und zeigt nacheinander auf die zu löschenden Elemente. Neben der eigentlichen Zuweisung (=) muß in der Schleife nur noch zu pfeld bei jedem Durchlauf der Wert sizeof(double) addiert werden (Auswertung von ++). Die aufwendige Multiplikation entfällt, außerdem hat man statt zwei Additionen nur noch eine.
1. Wenn man die Plattform wechselt danach IMMER qmake ausführen. Oder gleich das ganze Projekt bereinigen.
2. Wenn man mit OpenGl arbeitet, solle man Display Listen erst dann erstellen, nachdem initializeGL() aufgerufen wurde
3. Bei allen Objeken, die das QMainWindow als parent haben, braucht man sich nicht um die Speicherfreigabe kümmern?
Ist das korrekt?
QMainWindow ist von QWidget abgeleitet
QWidget ist von QObject abgeleitet
Alle Objekte, die von QObject abgeleitet sind und als parent ein von QObject abgeleitete Klasse haben werden beim zerstören des parent's über delete mitgelöscht.
Der Computer speichert Text, also einzelne Zeichen byteweise ab. Pro Byte können 256 unterschiedliche Buchstaben gespeichert werden. Es würden aber 7Bit (128 Möglichkeiten) langen um alle druckbaren Buchstaben zu speichern. Das achte Bit ist also immer 0.
Dieses eine freie Bit kann nun genutzt werden um ein Bit vom nächsten Buchstabend zu speichern. Es bleiben nur noch 6Bit vom zweiten Buchstabend und folglich sind 2Bit frei die vom dritten Buchstabend genutzt werden können u.s.w.
Es werden pro Byte 1Bit eingespart. Das entspricht einer Datenreduzierung um 12.5%.
Der Code ist in C geschrieben, weils so schön einfach ist. Die Eingangsdatei muss allerdings immer ein vielfaches von 8Byte groß sein, sonst gibt es Fehler bei entpacken. Auch darf die Eingangsdatei nur Text enthalten.
Stromausfall und die USV hat nicht lange genug gehalten
http://www.echo-online.de/suedhessen/darmstadt/Stromausfall-nach-Trafobrand;art1231,916370
Möchte nurmal ein paar Gedanken niederschreiben. Wenn ihr euch mal dieses Bild [1] anschaut (in dem Ordner gibts noch mehr), dann is Dreieck Nummer 434 eine Sackgasse.
Man sieht schön wie die Nummerierung von links nach rechts läuft, und irgendwann
kommt sie zurück und läuft von rechts nach links und dann BUMM, landet sie in dem Loch.
Was dann passiert ist klar, ein Schritt zurück und dann weiter.
Das Netz gehts übrigends nicht nach unten weiter. Muss mal ein besseren Screenshot machen.
Mein Gedanke ist nun, bei den Dreiecken 22,23,24,434 wird es immer, egal wie, eine Sackgasse geben. Ich habe mal eine Weile darüber nachgedacht und festgestellt, dass sowas immer passiert wenn man, im einfachsten Fall, 2 Dreiecke hat. Und eins davon liegt mit einer Seite an einer Wand. Oder bildet den Rand vom Netz. Jedenfalls kann man ein Dreieck von allen Seiten betreten und verlassen und das andere nur von 2.
Und wenn das der Fall ist, gibt es immer Sackgassen.
Das ist für den Nachfolgenden Algo ein Problem, da dann die Knotennummerierung (die Ecken der Dreiecke) nicht mehr stimmt.
Jedenfalls ist das ein Problem, wo ich Momentan keine Lösung sehe. Kennt jemand das Königberger Brückenproblem [2] ? Das selbe in grün.
Die andere Sorte von Sackgassen ist vllt. nicht ein Dreick "Loch" tief sondern 10 oder 100. Oder auch 500. Das sind ganze Teilbereiche von einem Netz.
Auch brauch ich eine "Linie", die jedes Dreieck besucht, ohne Unterbrochen zu werden. Also eine Space Filled Curve. Hilber Kurven und sowas. Aber die gibt es nur für quadratische oder vllt. auch für anders geformte Netze. Aber für ein beliebig geformtes Netz ist mir nichts bekannt.
Und da wären wir bei Fraktalen. Ob das da rein passt?
Nunja, danke fürs lesen
Und wenn jetzt einer sagt, hey das kenne ich. Lies doch mal das uns das, bitte melden
Gruss
[1] http://kater.mypets.ws/temp/40MBNetz/loch.png
[2] http://de.wikipedia.org/wiki/K%C3%B6nigsberger_Br%C3%BCckenproblem
Hier klicken bitte
http://dontknow.me/at/?http://www.facebook.com/help/contact.php%3Fshow_form=delete_account
Mal sehen obs funktioniert hat
Nun geht es um unser erstes Programm. Es soll ein Bild geladen und angezeigt werden.
Hier der Code:
#include "highgui.h"
int main(int argc, char** argv) {
IplImage *img = cvLoadImage(argv[1]);
cvNamedWindow("Example1", CV_WINDOW_AUTOSIZE);
cvShowImage("Example1", img),
cvWaitKey(0);
cvReleaseImage(&img);
cvDestroyWindow("Example1");
}
Nun wird das Programm compiliert und von einer Konsole mit einem Argument aufgerufen. Z.B. "./meinProgramm bild1.jpg". Es sollte sich nun ein Fenster öffnen und das Bild anzeigen.
Das Programm ist ganz einfach. IplImage enthält immer Bilder die man später bearbeiten will.
cvLoadImage() läd Bilder von der Festplatte wobei das Format automatisch erkannt wird.
Mit cvNamedWindow() wird ein neues Fenster mit dem internen Namen Example1 erstellt in dem vorerst die Bilder angezeigt werden. Später übernimmt das Qt für uns.
Mit cvShowImage() wird nun das Bild im vorher erstellten Fenster angezeigt.
cvWaitKey() stopt das Programm für die angegebene Zeit bzw. wartet, dass der User eine Taste drückt. cvWaitKey() ist zwingend notwendig sonst wird das Programm sofort beendet bzw. es erscheint einfach kein Bild.
cvReleaseImage() gibt den reservierten Speicher vom Bild wieder an das Betriebssystem zurück und cvDestroyWindow() zerstört das Fenster.
Ja, hast du? Dann komm doch mal bei darmstadt@conference.jabber.org vorbei. Vllt. finden sich ein paar Leute aus Darmstadt und Umgebung.
Einfach mal rein schauen.
Powered by WordPress