#ifndef CAM_H_INCLUDED
#define CAM_H_INCLUDED
#include <cv.h>
#include <highgui.h>
#include "Position.h"
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
class Cam
{
    public:
        IplImage* imgTracking;
        IplImage* GetThresholdedImage(IplImage* imgHSV, CvScalar lower, CvScalar upper);    //This function threshold the HSV image and create a binary image
        Position getPosition(IplImage* imgThresh);  //to find the position

      //start WebCam
      CvCapture* capture =0;
      capture = cvCaptureFromCAM(0);
      int startCam(capture)
      {
      //CvCapture* capture =0;
      //capture = cvCaptureFromCAM(0);
      if(!capture)
        {
            std::cout << "Capture failed" << std::endl;
            return -1;
        }
        IplImage* frame =0;
        frame = cvQueryFrame(capture);
        if(!frame) return -1;
      }
};
#endif // CAM_H_INCLUDED

Das wäre der Code aus dem Header Cam.h
nun möchte ich im Hauptprogramm meine Camaktivierung benutzen

#include <cv.h>
#include <highgui.h>
#include "Position.h"
#include "Cam.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sstream>
#include <iostream>

using namespace std;

Position getCoordinates(CvScalar lower, CvScalar upper)
{
    Cam control;
    startCam(frame);

    /*IplImage* frame=0;
    frame = cvLoadImage("/home/ubuntu/Bilder/Baelle.jpeg");
    if(!frame)
    return -1; für cam starten
    cout << "Error" << endl;*/

    control.imgTracking=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U, 3);   //create a blank image and assigned to 'imgTracking' which has the same size of original video
    cvZero(control.imgTracking);   //covert the image, 'imgTracking' to black
    frame = cvQueryFrame(capture);
    if(!frame) break;
    frame=cvCloneImage(frame);
    cvSmooth(frame, frame, CV_GAUSSIAN,3,3); //smooth the original image using Gaussian kernel
    IplImage* imgHSV = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 3);
    cvCvtColor(frame, imgHSV, CV_BGR2HSV); //Change the color format from BGR to HSV
    IplImage* imgThresh = control.GetThresholdedImage(imgHSV, lower, upper);
    cvSmooth(imgThresh, imgThresh, CV_GAUSSIAN,3,3); //smooth the binary image using Gaussian kernel
    Position position = control.getPosition(imgThresh);   //track the possition of the Roboter
    cvAdd(frame, control.imgTracking, frame); // Add the tracking image and the frame

    cvReleaseImage(&imgHSV); //Clean up used images
    cvReleaseImage(&imgThresh);
    cvReleaseImage(&frame);

    cvWaitKey(1);
    //cvDestroyAllWindows() ;
    return position;
}

Meine Fehlermeldung ist, diese, dass capture keinen Typ bezeichnet. Ich denke mal ich hab hier noch ein Problem bzgl meiner Klasse in ein Hauptprogramm oder so. Wäre echt klasse wenn mir jemand helfen könnte.
Bei Bedarf schick ich auch gerne das gesamte Projekt. Ist halt nur etwas zu groß für ein Forum hier.

Danke!!!

class Cam
{
    CvCapture* capture = 0; 
    capture = cvCaptureFromCAM(0);

    int startCam(capture) // Methode
    {
        // ...
    }
};

Du definierst eine Membervariable vom Typ CvCapture* mit Namen capture. Ok soweit, aber das = 0 gehört da nicht hinter. Das gehört in den Konstruktor.

Genauso gehört in den Konstruktor, dass du dem capture das Ergebnis des Funktiosnaufrufs cvCaptureFromCAM(0) zuweist. (Wieso eigentlich erst eine Nullzuweisung und danach was anderes? Wieso nicht direkt das "andere"?)

Dann definierst du dir eine Methode startCam mit Rückgabetyp int, ok soweit. Die Parameterdeklaration ist jedoch falsch. capture müsste eine Typ sein, damit die Syntax korrekt ist, ist es jedoch nicht wie wir 2 Zeilen vorher gesehen haben. Das dürfte der Fehler sein, den du meinst.

In deinem zweiten Codesnippet ist der zugehörige Aufruf von startCam übrigens auch falsch.

Du solltest ein halbwegs gutes Buch konsultieren und ja nicht glauben, dass das Mischen von C und C++ super toll und gut ist.

Edit: Bezog mich auf Zeile 30 der main, hab das im Header gar nicht gesehen.

bzgl c und c++ mischen, ich hatte zu Anfang auch cout stehen aber da kam immer eine Fehlermeldung dass cout etc nicht im Gültigkeitsbereich definiert wurde Obwohl IOSTREAM included hatte.

um die Funktion startCam aufzurufen in meinem Programm, muss ich doch Cam::startCam() schreiben oder?

tja mehr weiß ich leider nicht. Aber danke für die Tips. Aber so richtig kann ich leider noch nichts damit anfangen einfach zu wenig Kenntnis und zu wenig Zeit sich die noch anzueignen.

#ifndef CAM_H_INCLUDED
#define CAM_H_INCLUDED
#include <iostream>
#include <cv.h>
#include <highgui.h>
#include "Position.h"
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
class Cam
{
    public:
        IplImage* imgTracking;
        IplImage* GetThresholdedImage(IplImage* imgHSV, CvScalar lower, CvScalar upper);    //This function threshold the HSV image and create a binary image
        Position getPosition(IplImage* imgThresh);  //to find the position
        CvCapture* capture;

};

Cam::startCam(capture)
{
    capture = 0;
    capture = cvCaptureFromCAM(0);
    int startCam(capture)
    {
      //
      //capture = cvCaptureFromCAM(0);
      if(!capture)
        {
            std::cout << "Capture failed" << std::endl;
            return -1;
        }
        IplImage* frame =0;
        frame = cvQueryFrame(capture);
        if(!frame) return -1;
    }
}

#endif // CAM_H_INCLUDED

bekomme aber noch eine Fehlermeldung bzgl des konstruktors / dekonstruktors.
Freue mich über Hilfe
Danke

Ich hab zwar schon etwas über Konstruktor gelesen aber so wirklich verstanden hatte ich es nicht und dachte eigentlich ich komme auch ohne aus.

Nicht böse gemeint, aber wenn Du nicht weißt was ein Konstruktor ist, sind WebCams und OpenCV noch ein paar Nummern zu hoch für Dich.

Dein Parameter hat keinen Typ: von welcher Klasse ist capture? Du musst schreiben:

int startCam(CvCapture* capture)

Ein Konstruktor initialisiert einfach ein Objekt einer Klasse:
Wird ein Objekt einer Klasse erzeugt wird immer zuerst der Konstruktor aufgerufen. Jede Klasse hat einen Konstruktor, wird keiner explizit definiert tut der einfach garnichts: Klassenname(){}
Destruktor ist das Gegenstück wenn ein Objekt zerstört wird

Tja, das interessiert aber niemanden am Lehrstuhl wo ich meine Masterarbeit schreibe

Dann zählt es zum umfang der Masterarbeit, dass du dich da reinliest.

Darf man fragen was du studierst?

Deine Fehler:

• In der Klassendefinition taucht weder eine Deklaration eines Konstruktors noch der Funktion startCam auf. Das passt nicht zu Deiner Beschreibung, dass mit dem Konstruktor etwas nicht stimme. Es gibt ja gar keinen. Es passt auch nicht zu der startCam-Funktion, die Du darunter defnierst. Die hättest du in der Klasse deklarieren müssen.
• Funktionsparameter haben Typen und (normalerweise) einen Namen. Bei deiner startCam-funktion steht in der Klammer für die Funktionsparameter nur "capture". Was soll das sein?
• Solche Funktionen wie startCam definiert man nicht in einer Header-Datei. Du musst unbedingt die One-Definition-Rule kennenlernen um das Konzept der getrennten Übersetzung zu verstehen.