Bilder einer Webcam / DV-Cam analysieren

Hallo,

Ich versuche zur Zeit eine Bilderkennung mit Visual Basic 6 zu programmieren. Für den Anfang würde es Reichen, wenn ich
in einem Bild mal Farben finden würde und diese Grafisch
darstellen kann. Als Kamera stehen eine Standard Webcam mit einer
Auflösung von 640x480 interpoliert, oder eine SONY DV-Camera mit
Firewire und eine Auflösung von ~720x600 bereit.

Mein Ansatz war, dass ich die Abfrage max. 4x in der Sekunde mache.
Ich zeige das Entsprechende Bild in einer PictureBox an und überprüfe
jedes 5 Pixel auf seine Farbe. Finde ich eines das den Kriterien entspricht, suche ich im Umkreis weiter. Dann muss ich Irgendwie das Zentrum des Farbkfleckes Erkennen und somit die Bewegung einer Farbe erfassen.

Wenn das mal einigermaßen funktioniert, würde ich gerne eine Einfache
Objekterkennung mittels einer Kantenerkennung realisiere. Doch darüber
habe ich noch keinerlei brauchbare Informationen gefunden, die das
ausführlich erläutern.

Die Antworten müssen nicht auf Visual Basic bezogen sein, sondern
können gerne auch allgemein gehalten werden.

Ich freue mich über jede Hilfe.

Grüße
... nux ...

Also, ich wei ja nicht, aber wie du des beschreibst, wird des nciht sehr schnell werden... Es wäre wohl am schnellsten , wenn du des Bild nicht erst anzeigen würdest und es dann mit der lamen point Methode machst, sondern man müsste die Signale der Webcam gleich ohne des langsame anzeigen abfragen... Wie des allerdings gehen soll, da kann ich dir net helfen ^^ Vlt gibts ja irgendeine API die dies schaft...
Gruß Javik

So was in etwa hatten wir schon mal im Gespräch, damals haben wir ein Programm gefunden, womit das erfassen eines Bildes von einer Webcam möglich war.
Ich habs ma angehängt. Vielleicht kannsts ja was mit anfangen, ich hab mir das noch nich so wirklich angeguckt, weil ich gar keine Webcam hab 8-[

mfg God

Arrg, der Beitrag oben is von mir.

mfg

Hi!
Ich bin auch gerade dabei sowas zu schreiben(in VB).
Aber selbst das auslesen jedes einzelnen Pixel dauert auf einem 3 GHZ Rechner mit der API ungefähr eine halbe Sekunde.
Das finden des hellsten Punkt dauert nochmals 0,3 S(Auflösung 320 * 240).
Vielleicht gibt es ja noch eine schnellere Methode in VB.
Wäre auch dran interessiert.
MFG
Rasmus

Hi!

Ich glaub ne andere Möglichkeit wäre noch das Bild von der Webcam in ner PictureBox reinzusetzen, wie es das Programm ja schon macht und dann einfach die einzelnen Pixel abfragen, oder hast du das scho so gemacht?

mfg God

Ich habe den Videostream mit der API empfangen und danach mit einer APIfunktion den RGB Wert jedes einzelnen Pixels ausgelesen.
Danach habe ich die Farbwerte Verglichen und den hellsten Punkt definiert.
Das ganze hat ungefähr 1S gedauert.
MFG
Rasmus

Es gibt ne API names GetPixel. Ist glaub ich in der GDI32-DLL enthalten, das weiß ich jetzt nicht so genau. Diese API kann im Prinzip genau das selbe wie Point, ist aber um etwa 30% schneller.

Gruß, Trabukh

@Trabukh
Ja das stimmt, aber so wie ich das mache geht es noch um einiges schneller.
MFG
Rasmus

robotxy so mache ich es auch aber bei mir geht es unter ein sekund für den vor gang brauch ich 250 msec. wieviel punkte verarbeitest du ?

hast du ausdem hellsten punkt noch was programmiert ?

https://www.roboternetz.de/phpBB2/vi...er=asc&start=0

hier kannst du mein erfolge nicht erfolge ansehen

@Numberfive
Das Programm zeigt in dem einen Fenster den Livestream an.
Davon macht er jede Sekunde einen Screenshot.
Bei diesem ließt er jedes Pixel ein(320 *240).
Danach sucht er den hellsten Punkt.
Das ganze dauert 834ms.
Ohne die Livebildübertragung von der Cam im Hintergrund,
würde das ganze bestimmt um einiges schneller gehen.
Als nächstes kommt das Erkennen der Bewegungsrichtung des Fahrzeuges.
Wie gut funktioniert es schon bei dir?
MFG
Rasmus

Hallo Rasmus,

die Technik ist sehr änlich bzw. gleich selbe grösse.
nur das ich das bild direckt im direcktX treiber abhole
und so mit in der stream paralle anzeigen kann fast
kein zeit verlust duch den stream. Habe auch nur ein amd 1000.

Das was du da vorhast hört sich gut an und wenn ich mir dazu dein alter ansehe werde ich rot.

Also bei mir funktioniert die Bewungserkunng in so weit das weiß wenn
sich was vor der cam bewegt. habe dann mit mit der kanten erkennung
angefangen was zwar langsam ist aber ber kontrast reichen bilder funktioniert.(ca. 800 msec)
Da ist jetzt die Software stehen auch geblieben kam irgend wie nicht dazu weiter machen.
Da ich gefrustet war und auch im geschäft ziemlich eingebungen.

Hast du dir mal die bilder in den anderen thread angekuckt da kann ziemlich viel erkennen finde ich.

wie willst du die richtung erkennung machen ehrlich gesagt ich habe es bis jetzt nicht hin bekommen.

Vielleicht können wir ja zusammen arbeiten ?

Gruß

Naja, nach dem ich mir das nochmal überlegt habe,
werde ich doch mit der Kantenerkennung anfangen.
Bei dir funktioniert es ja schon richtig gut.
Gibt es nicht eine Möglichkeit aus den Ergebnissen eine 3D Karte zu zeichnen?
Du hast doch in C++ programmiert oder?
Werde mich in den nächsten Tagen mal an die Kantenerkennung setzen.
MFG
Rasmus

Ja ich habe mit c++ programmiert aber das ist doch fast egal weil der
algorytmus muß tuen und schnell sein damit ist die programmier
sprach fast egal. kann vb gut gelesen ich weiß ja nicht wie du C code lesen kannst. ich male die erkannten kannten ein fach mit setpixel
auf ein fenster neben dem viedeo bil so kann ich erkennen was der
algorytmus macht. da man das ergebnis eh speichern muß dami man
nachher vergleichen kann ist das nicht so schlimm ausdem ist im debug die geschwindig keit nicht ganz so tragisch kann man im release dann wieder ausschlaten bzw. in vb kann sachen mit debug ausgabe oder ohne.

Mein problem zur zeit:

00000000
01111110
01000010
01000010
01111110

wie erkennt man daraus das es ein viereck ist ?
oder ein kreis oder so.
bzw ist das in der mitte oder rechts oder links

die zahlen bedeuten nur 1 = kante 0 = keine Kante

ich hoffe du kannst mir folgen

Ja, ich kann dir folgen.
Mein Problem ist das die SetPixel Funktion nur im Form und nicht in einer Leeren PictureBox funktioniert.
Man müsste doch die 90° Winkel erkennen können, oder ?
MFG
Rasmus

Mein Kantenerkennungs Algo funktioniert schon gar nicht so schlecht.
Ich habe mal einen Screenshot gemacht.

So ich hab jetzt auchmal sowas gemacht :)
Hat 5 Minuten gebraucht, is deshalb no net so gut, aber ich werde es noch verbessern.... Des Bild is noch von ner älteren Version, aber viel besser hab ichs noch nicht hinbekommen...
Zu dem Problem mit der erkennung von kästchen hab ich noch keine lösung, aber ich werde auch mal überlegen !

Das gefällt mir auch sehr gut, bloß wird es bei dir nicht ganz einfach mit der Erkennung eines Viereckes, da die Linien sehr Ungleichmäßig sind.
Bin schon gespannt auf die Nächsten Ergebnisse.
MFG
Rasmus

...also meinen absoluten Respekt für jeden der sowas hin kriegt!..nur so nebenbei.... :-)

Ich habe schnell noch einen Algo geproggt ein Kreuz erkennt, bevor ich weg fahre. Er erkennt große als auch kleine Kreuze.
Aber leider erkennt er sie bis jetzt nur, wenn sie sich vom Untergrund abheben(also nicht schwarze auf grauem Untergrund).
Die Farbe, des zu erkennenden Kreuzes muss vorher eingestellt werden.
Mit mit dem Einlesen der Pixel dauert das ganze 141ms.
Habt ihr noch Ideen?
MFG
Rasmus

Die Sache mit der Pixelerkennung ist echt genial. Aber leider hab ich nur delphi und kein VB habt ihr da ne kostenlose Lösung für mich

gruß

Xeus

Ähm ? Was stellts du dir vor ?
Du kannst es dir doch auch in Delphi Programmieren ?!

Aber ich trau mir das nicht zu wenn ich ehrlich bin wär halt cool wenns da schon was gäb.

Du meinst du willst diese Kantenprogramm ? Des is zwar net schwer aber ok... Wenn ichs dir gebe bringts dir auch nix, weil du mit dem Programm nichts anfangen kannst. Des bringt dir nur was wennst des irgendwo einbinden kannst und dazu musst du des individuel anpassen

Ich werds versuchen, hab zwar noch keine AHNUNG wie aber es ist noch kein Meister vom Himmel gefallen.

Hallo,

erstmal finde ich es toll, dass sich hier einige an die Bildverarbeitung heranwagen. =D>
Vielleicht könnt ihr ja die von euch verwendeten Algorithmen (z.Bsp. zur Kantenerkennung) ein wenig erläutern, damit alle etwas davon haben.
Evntl kann man dann gemeinsam den Code etwas optimieren und bessere Laufzeiten erreichen (800ms für die Kantenerkennung ist schon ne Menge, das lässt sich sicher auf einen Bruchteil reduzieren).

Ich glaub du stellst dir des etzwas zu einfach vor den code zu verlkeinern... Ich werde des Prograsmm jetzt mal in VB.Net machen, vlt is des da schneller...
Ich denke wenn man sich hinzetzt und es wirklich will dann bekommt mans auch selber raus ^^
Wo ein Wille ist ist auch ein Weg....
Ihr schaft dass schon ;) Einfach mal überlegen wo kannten sein könnten. Vlt sind se ja da wo eine farbe in eine andere übrgeht ?!?! ALso jetzt isses ja wirklich nimmer schwer ^^

Moin,
da ich gestern erst aus dem Urlaub wiedergekommen bin, habe ich jetzt erst diesen Thread gesehen.

Mal eine Frage: Was wollt ihr mit der Kantenerkennung anfangen? So wie ich das sehe, fragt ihr Pixel für Pixel ab, ob er an einer Kante liegt. Und wenn das so ist, zeichnet ihr einen Punkt, wodurch dann ein Bild entsteht, dass die Konturen des Bildes zeigt. Was aber noch fehlt, und ohne das kann der Roboter damit wohl nie was anfangen, ist die Umwandlung in Pfade. Schwarze Punkte, die nebeneinander liegen, machen unser Auge zwar automatisch zu einer Linie, der Rechner tut das aber nicht so einfach. Überlegt mal, wie man die Punkt-Matrix zu einer Ansammlung von Linien macht. Und dann wird es auch nicht mehr so schwierig sein, ein Quadrat von einem Kreis zu unterscheiden.

Gruß
Johannes

Zitat:

---

Ich glaub du stellst dir des etzwas zu einfach vor den code zu verlkeinern...

---

Ich weiß nicht, mein Versuch zur Kantenerkennug braucht auf nem Duron 700 bei einem 640x480 Bild ganze 80ms ...

Man kann das Problem auf verschiedene Arten lösen. Einfach suchen, wo sich die Farben ändern oder eben einen effizienten Algorithmus verwenden, der im Prinzip das gleiche macht, aber eben effizienter. Darauf will ich hinaus.
Das Forum heißt schließlich "... Algorithmen ...", also sollten wir hier nicht nur die Ergebnisse pärsentieren, sondern auch mal das Wie ansprechen.

Johannes hat natürlich recht, dass mit den Kanten allein noch nix gewonnen ist, hier muß sich zum Beispiel noch eine Bildsegmentierung anschließen, aber das is dann wieder eine andere Geschichte.

Genau das was Johannes anspricht versuche ich im moment...

Zerram , bist du dir sicher das des stimmt ?? Ich hab in Vb auch den hauseigenen timer mitlaufen lassen der hat mir 67 ms angezeigt... aber der genauere Timer einer API hat dann eben 700ms angezeigt.... Ich willd deine Programmierkünnste nicht in frgae stellen aber für mich hört sich das sehrt unwarscheinlich an...

Warum postet Ihr denn nicht einfach eure Codes? Oder wenigstens die Algos, wie zefram schon gesagt hat. Das würde vieles um Einiges einfacher machen.

Gruß
Johannes

Also ok, unter www.tu-chemnitz.de/~niko/biber gibts die .exe und ein paar Testbilder.

Bitte beachten: Das Prog schluckt im Moment nur .bmp mit 256 Graustufen.

Der C++ Algorithmus zur Kantenerkennung:

Code:

---

/**************************************************************************
*  Methode:            sobel_kombiniert                                  *
*  Sichtbarkeit:        public                                            *
*  Parameter:          schwelle                                          *
*                                                                        *
*                                                                        *
*  Funktion:            führt eine Faltung mit dem beiden                *
*                      Sobel-Operatoren aus (Gradientenverfahren),      *
*                      benutzt den  in 'schwelle' übergebenen Wert zur  *
*                      Binearisierung des Bildes                        *
***************************************************************************/
bool TbiberImage::sobel_kombiniert(TbiberPix schwelle,TbiberPix *oldPix)
{TbiberPix kern1[3][3]={ {1,0,-1},
                        {2,0,-2},
                        {1,0,-1}};
 TbiberPix kern2[3][3]={ {1,2,1},
                        {0,0,0},
                        {-1,-2,-1}};
  int summe=0,s1=0,s2=0;
  int x,y;
  TbiberPix* newPix;
  int *ykoord, y1,y2,y0;

  if (!(newPix=(TbiberPix*)calloc(TbiberImage::size,sizeof(TbiberPix)))) return false;
  if (!(ykoord=(int*)calloc(width,sizeof(int)))) return false;
  if (oldPix) memcpy(oldPix,pixels,TbiberImage::size*sizeof(TbiberPix));


  for (y=0;y<height;y++) ykoord[y]=y*width;

  for (y=1;y<height-1;y++)
  {    y0=ykoord[y];
        y1=ykoord[y+1];
        y2=ykoord[y-1];
        for (x=1;x<width-1;x++)
        {      s1=-getPix(y2+x-1)+getPix(y2+x+1)-2*getPix(y0+x-1)+2*getPix(y0+x+1)-getPix(y1+x-1)+getPix(y1+x+1);
                s2=-getPix(y2+x-1)-2*getPix(y2+x)-getPix(y2+x+1)+getPix(y1+x-1)+2*getPix(y1+x)+getPix(y1+x+1);

              //  summe=sqrt(pow(s1,2)+pow(s2,2));
                summe=(abs(s1)+abs(s2)) /2;

                if (schwelle)
                {      if (summe<schwelle) summe=0;
                        else summe=255;
                }
                else if (summe>255) summe=255;

                newPix[y*width+x]=(TbiberPix)summe;
        }
  }

  memcpy(pixels,newPix,TbiberImage::size*sizeof(TbiberPix));
  free(newPix);

  return true;
}

---

... ist eine Faltung mit dem horizontalen und vertikalen Sobel-Operator.

Das letzte Posting war von mir, sorry.

Noch was zu dem Programm: Lade mal das bild rechtecke2.bmp und wähle dann im Menü Segmentierung das Zeilenkoinzidenzverfahren. In der drop-down Liste kann man dann alle gefundenen Objekte durchgehen und unten wird angezeigt, ob es als Rechteck, Sechseck usw. erkannt wurde.
Dafür wird die Datei "objekte.dat" benötigt.

Hi!

Ich habe auch letztens mit graphischer Bearbeitung angefangen.
Nur habe ich als einzige Lösung, dass ich jeden Pixel einzelln auslese und die RGB werte Checke.
Dafür brauche ich dann pro Bild etwa 3s!!!!

Wenn ich mit mal eure Zeiten so angucke, naja!

Könnt ihr mit mal bitte posten, welche API's ihr benutzt und vieleicht noch ein bissele Code?
Wär echt net.

Mit freundlichen Grüßen
Baumrinde

Ach ja: Ich Code natürlich auch in VB!

Ich hab eigentlich keine APIs benutzt nur eine um die Zeit zu stoppen...

Wie bearbeitet ihr denn sonst die Bilder?

Ihr solltet die Bilder auf keinen Fall innerhalb irgendeiner PictureBox oder wie immer sich das Steuerelement unter VB nennt, bearbeiten. Kopiert euch die Pixel in ein großes Array im Speicher und führt eure Operationen dort aus. Die Zugriffe auf die einzelnen Pixel über die Steuerelement-Methoden zu machen, erzeugt eine ganze Menge Overhead, den man nicht braucht.

(VB ist vielleicht auch nicht unbedingt die beste Wahl für zeitkritische Operationen, aber das ist prinzipiell erstmal egal.)

Quellcode: Den Anfang hab ich gemacht, das Prog steht auch online, vielleicht zieht jemand nach ...

Ich denke du bist zefram?

Ich habe mir deine Sachen kurz angeschaut, aber vielleicht kannst du nochmal eine kurze Anleitung geben. Leider habe ich im Moment keine Zeit, selbst an dem Thema zu arbeiten. Ich verfolge den Thread aber trotzdem weiter.

Gruß
Johannes

Hallo,

ich habe mal eben ein kurzes Tutorial zum Thema Kantenerkennung geschrieben. Es geht nicht auf die Umsetzung in eines Programmiersprache um, sondern zeigt allein den Algorithmus.

Das Tutorial gibts hier als PDF unter http://www.tu-chemnitz.de/~niko/bibe...l/tutorial.pdf .

Bei entsprechendem Feedback bin ich auch gern bereit, das Tutorial weiter auszubauen und weitere Themen darzustellen. Das aber natürlich nur, wenn sich auch jemand ernsthaft für solche Sachen interessiert und es dann auch liest :)

Hallo zefram,

Ich habe das Tutorial gelesen und freue mich wirklich, dass ich nun
etwas handfestes habe auf dem ich meine Kantenerkennung aufbauen
kann. Wenn sich noch weiter Personen für dieses Projekt begeistern
könnten, würde ich mich über eine Fortsetzung des Tutorials sehr freuen.

Vielen Dank, Grüße nux