ich bin neu hier im Forum und in Bezug auf c++ leider nicht so richtig fit.

Ich hoffe das ich alle wichtigen Informationen zur Verfügung gestellt habe und das mir jemand helfen kann/möchte.

Um die Übersichtlichkeit zu wahren, werde ich nur einen Ausschnitt meines bisherigen Quelltextes darstellen.
Wie bereits schon der Titel verrät, habe ich eine Fehlermeldung bezüglich meiner Klasse IMAGE. Hier die Ausgabe des Terminals:

g++ -Wall main.cpp image.cpp hist.cpp -ltiff -o ausgabe
image.cpp:405:20: Fehler: keine Elementfunktion »void IMAGE::invert()« in Klasse »IMAGE« deklariert
make: *** [all] Fehler 1

Ich habe (zumindest dachte ich das) die Funktion invert() wie folgt definiert:

image.h:

#ifndef IMAGE_H
#define IMAGE_H
class IMAGE{
public:
void invert();
};
#endif

image.cpp:

#include "image.h"
void IMAGE::invert(){}

ich habe allen Inhalt von "invert()" entfernt um andere Fehlerquellen ausschließen zu können.

Ich habe bereits schon einige Funktionen erfolgreich deklarieren können und sehe einfach nicht, was ich in Bezug auf invert anders mache als bisher.
Ich kann irgendwie keine weiteren Elementfunktionen mehr deklarieren.

Was aber funktioniert ist: invert als inline-Funktion zu deklarieren.
Aber das ist nicht das, was ich gern hätte.

Vielen dank
Beste Grüße Mephisto

Um die Übersichtlichkeit zu wahren, werde ich nur einen Ausschnitt meines bisherigen Quelltextes darstellen.

Wenn du so etwas machst, solltest du prüfen, ob der Ausschnitt denselben Fehler erzeugt. Hier ist das nicht der Fall. Du hast also den Fehler mit ausgeschnitten.

=> [c]g++ -Wall image.h[/c] [...] ?

Mmh, ich kann mir aber leider nicht erklären, was ich weggelassen haben könnte.

Ich habe oben erwähntes genauso in meinem Quelltext stehen.
Wenn es gewünscht ist, würde ich den gesamten Quelltext der image.h und image.cpp hier rein stellen.

Für jede weitere Funktion die ich wie folgt implementiere kommt selbiges Verhalten:

g++ -Wall main.cpp image.cpp hist.cpp -ltiff -o ausgabe
image.cpp:405:20: Fehler: keine Elementfunktion »void IMAGE::invert()« in Klasse »IMAGE« deklariert
image.cpp:406:18: Fehler: keine Elementfunktion »void IMAGE::test()« in Klasse »IMAGE« deklariert
make: *** [all] Fehler 1

image.h:

#ifndef IMAGE_H
#define IMAGE_H

#include "tiffio.h"
#include <stdlib.h>
#include <math.h>

class IMAGE
{

public:
void invert();
void test();
};

image.cpp:

#include "image.h"
void IMAGE::invert(){}
void IMAGE::test(){}

image.h:

#ifndef IMAGE_H
#define IMAGE_H

#include "tiffio.h"
#include <stdlib.h>
#include <math.h>

class IMAGE
{

public:

//Konstruktoren
IMAGE();
IMAGE(const char*);

//Kopierkonstrutkor

IMAGE(const IMAGE &);

//Destruktoren
~IMAGE(){};

/*### Lese - Funktionen ###*/
uint32 ReadWIDTH() const;
uint32 ReadLENGTH() const;
uint16 ReadBPS() const;
uint16 ReadSPP() const;
unsigned long ReadROWSPS() const;
unsigned long ReadBUFFERSIZE() const;
int ReadSCANLINESIZE() const{return TIFFScanlineSize(image);};
void ReadIMAGEDATA() const;

/*### Get - Funktionen ###*/

uint16 GetBufferValue(int i){return this->buffer[i];};
uint16 GetBPS(){return *this->bps;};
uint16 GetSPP(){return *this->spp;};
//uint16 GetStripOffset();
uint16 GetRowsPerStrip(){return *this->rowsps;};
uint32 GetWIDTH(){return *this->width;};
uint32 GetLENGTH(){return *this->height;};
unsigned long GetBufferSize(){return *this->bufferSize;};
int GetScanlineSize(){return *this->scanlineSize;};
//tdata_t GetScanlineBuf(int);

/*### Set - Funktionen ###*/

void SetBufferValue(uint16 value, int i){this->buffer[i] = value;};
void SetBPS(uint16 _bps){*this->bps=_bps;};
void SetSPP(uint _spp){*this->spp=_spp;};
void SetRowsPerStrip(unsigned long _rowsps){*this->rowsps=_rowsps;};
void SetWidth(uint32 _width){*this->width=_width;};
void SetLength(uint32 _height){*this->height=_height;};
void SetBufferSize(unsigned long _bufferSize){*this->bufferSize=_bufferSize;};
void SetScanlineSize(int _scanlineSize){*this->scanlineSize=_scanlineSize;};

/*### Ausgabe - Funktionen ###*/

void PrintImageData();			//für Testzwecke
void PrintHeaderData();			//für Testzwecke

void CreateImage();

/*### Bild - Operationen ###*/

void schwarzZuWeiss(IMAGE&);
void berandung(IMAGE&);				//eventuell nicht gebraucht
void glaettung(IMAGE&);
unsigned long mittelwert();
void grauwertSchwaerzen(IMAGE&, uint16);
void grauwertVerschiebung(IMAGE&, uint16);	//nochmal überdenken
void grauwertStreckung(IMAGE&);			// OK
void Gauss_Tiefpass(IMAGE&);			// OK
void Sobel(IMAGE&);
void Sobel_X(IMAGE&);				//vorrübergehend
void Sobel_Y(IMAGE&);				//vorrübergehend
uint16 H_X(int i); 				// OK
uint16 H_Y(int i);				// OK
void invert();
void test();

/*### Hilfsfunktionen ###*/

uint16 SearchMax();
uint16 SearchMin();

private:
TIFF* image;

char *imageName;
uint16 *buffer;

uint32 *width, *height;
uint16 *bps, *spp;

unsigned long *rowsps, *bufferSize;
int *scanlineSize;

};

#endif

für die cpp reicht glaube ich der Fehlerproduzierende Ausschnitt (hoffe ich, sind ca 500 Zeilen)
image.cpp:

#include "image.h"
void IMAGE::invert(){}
void IMAGE::test(){}

für die cpp reicht glaube ich der Fehlerproduzierende Ausschnitt (hoffe ich, sind ca 500 Zeilen)

Nein, reicht nicht. Du sollst nicht hoffen oder glauben, du sollst prüfen.

Poste ruhig die cpp Datei, aber ohne den Inhalt der Funktionen/Methoden, also nur die Köpfe und das nötigste...

Zeile 385 und 386 stehen die beiden

#include "image.h"

/*
#################################
#				#
# Konstruktoren			#
#				#
#################################
*/

IMAGE::IMAGE(){
bps = 0;
}

IMAGE::IMAGE(const char* filename){
 image = TIFFOpen(filename, "r");
 bps = new uint16;
 *bps = ReadBPS();
 spp = new uint16;
 *spp = ReadSPP();
 rowsps = new unsigned long;
 *rowsps = ReadROWSPS();
 width = new uint32;
 *width = ReadWIDTH();
 height = new uint32;
 *height = ReadLENGTH();
 scanlineSize = new int;
 *scanlineSize = ReadSCANLINESIZE();
 bufferSize = new unsigned long;
 *bufferSize = ReadBUFFERSIZE();
 if(image == NULL){//überprüft ob das Bild geöffnet werden kann
  fprintf(stderr, "Bilddatei konnte nicht geoffnet werden\n");
  exit(42);
 }
 buffer = new uint16[*bufferSize+1];

 ReadIMAGEDATA();
 TIFFClose(image);
}

/*
#################################
#				#
# Kopierkonstruktor		#
#				#
#################################
*/

IMAGE::IMAGE(const IMAGE & img){
// image = TIFFOpen("newFile.tif", "w");
 bps = new uint16;
 *bps = *(img.bps);
 spp = new uint16;
 *spp = *(img.spp);
 rowsps = new unsigned long;
 *rowsps = *(img.rowsps);
 width = new uint32;
 *width = *(img.width);
 height = new uint32;
 *height = *(img.height);
 scanlineSize = new int;
 *scanlineSize = *(img.scanlineSize);
 bufferSize = new unsigned long;
 *bufferSize = *(img.bufferSize);

 buffer = new uint16[*bufferSize+1];
 for(unsigned int i=0; i < *bufferSize; i++) buffer[i] = img.buffer[i];
}

/*
#################################
#				#
# Lese - Funktionen		#
#				#
#################################
*/

uint16 IMAGE::ReadBPS() const{
 if(TIFFGetField(this->image, TIFFTAG_BITSPERSAMPLE, this->bps) == 0){
  fprintf(stderr, "Fehler beim einesen von bps");
  exit(42);
 }
 return *bps;
}

uint16 IMAGE::ReadSPP() const{

 if(TIFFGetField(this->image, TIFFTAG_SAMPLESPERPIXEL, this->spp) == 0){
  fprintf(stderr, "Fehler beim einlesen von spp");
  exit(42);
 }
 return *spp;
}

unsigned long int IMAGE::ReadROWSPS() const{

 if(TIFFGetField(this->image, TIFFTAG_ROWSPERSTRIP, this->rowsps) == 0){
  fprintf(stderr, "Fehler beim einlesen von rowsps");
  exit(42);
 }
 return *rowsps;
}

uint32 IMAGE::ReadWIDTH() const{

 if(TIFFGetField(this->image, TIFFTAG_IMAGEWIDTH, this->width) == 0){
  fprintf(stderr, "Fehler beim einlesen von width");
  exit(42);
 }
 return *width;
}

uint32 IMAGE::ReadLENGTH() const{

 if(TIFFGetField(this->image, TIFFTAG_IMAGELENGTH, this->height) == 0){
  fprintf(stderr, "Fehler beim einlesen von width");
  exit(42);
 }
 return *height;
}

unsigned long IMAGE::ReadBUFFERSIZE() const{

 unsigned long *tmp;
 tmp = new unsigned long;
 *tmp = TIFFNumberOfStrips(this->image) * TIFFStripSize(this->image);
 return *tmp;
}

//Notiz im Testfall: stripMax=1536 und stripSize=3840 (also 2*width)
void IMAGE::ReadIMAGEDATA() const{

 int stripMax = TIFFNumberOfStrips(this->image);
 tsize_t stripSize = TIFFStripSize(this->image);
 unsigned long result = 0;
 unsigned long imageOffset = 0;

 fprintf(stderr, "stripMax= %i stripSize= %i", stripMax, stripSize);

 for(int stripCount = 0; stripCount < stripMax; stripCount++){
  if((result = TIFFReadEncodedStrip(this->image, stripCount, this->buffer + imageOffset, stripSize)) == -1){
   fprintf(stderr, "Fehler strip Anzahl %d\n", stripCount);
   exit(42);
  }
  imageOffset += result;
 }
 fprintf(stderr, "imageOffset= %lu", imageOffset);
}

/*
#################################
#				#
# Ausgabe - Funktionen		#
#				#
#################################
*/

//Dient zum testen (überprüfen, ob auch richtig eingelesen worden ist)
void IMAGE::PrintHeaderData(){
 fprintf(stderr, "Width=%u Height=%u bps=%i spp=%i rowsps=%lu scanlineSize=%i bufferSize=%lu\n", *this->width, *this->height, *this->bps, *this->spp, *this->rowsps, *this->scanlineSize, *this->bufferSize);
// fprintf(stderr, "ImageOffset=%lu StripSize=%i\n", imageOffset, stripSize);
}

//Dient zum testen (überprüfen, ob auch richtig eingelesen worden ist)
//Aenderung vorgenommen: count < bufferSize -> count < 8
void IMAGE::PrintImageData(){
 for(unsigned long count = 0; count < 8; count++){ 
  fprintf(stderr, "%02x ", buffer[count]); 
 }
}

void IMAGE::CreateImage(){
 TIFF* out = TIFFOpen("myFile.tif","w");
 uint16* buf = NULL;
// char* img = new char[(*this->width)*(*this->height)*(*this->spp)];
 tsize_t linebytes = (*this->spp)*(*this->width);

 TIFFSetField(out, TIFFTAG_IMAGEWIDTH, *this->width);
 TIFFSetField(out, TIFFTAG_IMAGELENGTH, *this->height);
 TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, *this->spp);
 TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, *this->bps);
 TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
 TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, (*this->width)*(*this->spp)));

 if(TIFFScanlineSize(out) == linebytes) 
  buf = (uint16*)_TIFFmalloc(linebytes);
 else buf=(uint16*)_TIFFmalloc(*this->scanlineSize);

 for(uint32 row=0; row < *this->height; row++){
  for(int i=0; i<(*this->width); i++){ 
   buf[i] = buffer[i+row*2*(*width)];
  }
  TIFFWriteScanline(out, buf, row, 0);
 }

 (void) TIFFClose(out);
 if(buf) _TIFFfree(buf);
}

/*
void IMAGE::CreateImage(){

 TIFF* out = TIFFOpen("myFile.tif","w");

 TIFFSetField(out, TIFFTAG_IMAGEWIDTH, *this->width);
 TIFFSetField(out, TIFFTAG_IMAGELENGTH, *this->height);
 TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, *this->spp);
 TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, *this->bps);
 TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
 TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, (*this->bps)*(*this->width)*2));
 TIFFSetField(out, TIFFTAG_FILLORDER, 1);

 TIFFWriteEncodedStrip(out, 0, this->buffer, 2*(*this->width) * (*this->height));

 (void) TIFFClose(out);
}
*/
/*
#################################
#				#
# Bild - Operationen		#
#				#
#################################
*/

void
IMAGE::schwarzZuWeiss(IMAGE &inputImg){
 int H = *inputImg.height*2;
 int W = *inputImg.width;
 for(int h=0; h<H; h++){
  for(int w=0; w<W; w++){
   if(inputImg.buffer[w+h*W] == 0x0000)
    this->buffer[w+h*W] = 0xffff;
  }
 } 
}

void
IMAGE::berandung(IMAGE &inputImg){
 int H = *inputImg.height*2;
 int W = *inputImg.width;
 for(int h=0; h<H; h++){
  for(int w=0; w<W; w++){
   if((w==0)||(h==0)||(w==W-1)||(h==H-1))
    this->buffer[w+h*W] = pow(2, (*inputImg.bps)-1);
  }
 }
}

void 
IMAGE::glaettung(IMAGE &inputImg){
 int H = inputImg.GetLENGTH();
 int W = inputImg.GetWIDTH();
 uint16 m = 0;

 for(int h = 1; h < 2*H-1; h++){
  for(int w = 1; w < (W-1); w++){
   for(int x = -1; x < 2; x++){
    for(int y = -1; y < 2; y++){ //w+h*W + 2*x + y*W
     if((x!=0) || (y!=0)) m += inputImg.GetBufferValue(w+h*W + x + y*W);
     }
   }
   m = m / 8;
   if(inputImg.GetBufferValue(w+h*W) > m) this->SetBufferValue(m, w+h*W);
   m = 0;
  }
 }
}

unsigned long
IMAGE::mittelwert(){
 unsigned long mittelwertZeile=0;
 unsigned long mittel=0;
 int H = *this->height*2;
 int W = *this->width;
 for(int h=0; h<H*2; h++){
  for(int w=0; w<W; w++){
   mittelwertZeile += this->buffer[w+h*W];
  }
  mittelwertZeile = mittelwertZeile/W;
  mittel += mittelwertZeile;
  mittelwertZeile =0;
 }
 mittel = mittel / H;
 return mittel;
}

void 
IMAGE::grauwertSchwaerzen(IMAGE &inputImg, uint16 VF){
 for(unsigned int i=0; i<inputImg.GetBufferSize(); i++){
  if(inputImg.GetBufferValue(i) > (pow(2,*inputImg.bps -1)-VF)) this->SetBufferValue(0x0000,i);
 }
}

void 
IMAGE::grauwertVerschiebung(IMAGE &inputImg, uint16 VF){
 for(unsigned int i=0; i<inputImg.GetBufferSize(); i++){
   if(inputImg.GetBufferValue(i) > (pow(2,*inputImg.bps)-VF)) this->SetBufferValue(0x0000,i);
   else this->SetBufferValue(inputImg.GetBufferValue(i)+VF, i);
 }
}

void
IMAGE::grauwertStreckung(IMAGE &inputImg){
 uint16 Max = inputImg.SearchMax();
 uint16 long Min = inputImg.SearchMin();

 for(unsigned int i=0; i<*inputImg.bufferSize; i++){
  this->buffer[i] = ( (inputImg.buffer[i] - Min) * (pow(2, *inputImg.bps) -1) )/(Max-Min);
 }
}

void
IMAGE::Gauss_Tiefpass(IMAGE& inputImg){
 int H = inputImg.GetLENGTH();
 int W = inputImg.GetWIDTH();
 int m = 0;

 for(int h = 1; h < 2*H-1; h++){
  for(int w = 1; w < (W-1)*2; w++){
   for(int x = -1; x < 2; x++){
    for(int y = -1; y < 2; y++){ 
     if((x==0)&&(y==0)) m += inputImg.GetBufferValue(w+h*W + x + y*W) *2*2;
     if((x!=0)&&(y==0)) m += inputImg.GetBufferValue(w+h*W + x + y*W) *2;
     if((x==0)&&(y!=0)) m += inputImg.GetBufferValue(w+h*W + x + y*W) *2;
     else m += inputImg.GetBufferValue(w+h*W + x + y*W) ;
    }
   }
   m=m/16;
   this->SetBufferValue(m, w+h*W);
   m=0;
  }
 }
}

void
IMAGE::Sobel(IMAGE &inputImg){
 int H = *inputImg.height*2;
 int W = *inputImg.width;
 uint16 h_x=0,h_y=0;
 for(int h = 1; h < H-1; h++){
  for(int w = 1; w < W-1; w++){
   h_x = inputImg.H_X(w+h*W);
   h_y = inputImg.H_Y(w+h*W);
   this->buffer[w+h*W] = sqrt(h_x*h_x + h_y*h_y);
  }
 }
}
void
IMAGE::Sobel_Y(IMAGE &inputImg){
 int H = *inputImg.height*2;
 int W = *inputImg.width;
 for(int h = 1; h < H-1; h++){
  for(int w = 1; w < W-1; w++){
   this->buffer[w+h*W] = inputImg.H_Y(w+h*W);
  }
 }
}

void
IMAGE::Sobel_X(IMAGE &inputImg){
 int H = *inputImg.height*2;
 int W = *inputImg.width;
 for(int h = 1; h < H-1; h++){
  for(int w = 1; w < W-1; w++){
   this->buffer[w+h*W] = inputImg.H_X(w+h*W);
  }
 }
}

uint16
IMAGE::H_Y(int i){
 uint16 h_y = 0;
 for(int x = -1; x < 2; x++){
  for(int y = -1; y < 2; y++){ 
   if((x!=0)&&(y<0)) h_y += this->buffer[i+x+y*(*this->width)];
   if((x==0)&&(y<0)) h_y += this->buffer[i+x+y*(*this->width)] *2 ;
   if((x!=0)&&(y>0)) h_y += this->buffer[i+x+y*(*this->width)] *(-1);
   if((x==0)&&(y>0)) h_y += this->buffer[i+x+y*(*this->width)] *(-2) ; 
  }
 }
 h_y=h_y/8;
 return h_y;
}

uint16
IMAGE::H_X(int i){
 uint16 h_x = 0;
 for(int x = -1; x < 2; x++){
  for(int y = -1; y < 2; y++){ 
   if((x<0)&&(y!=0)) h_x += this->buffer[i+x+y*(*this->width)];
   if((x<0)&&(y==0)) h_x += this->buffer[i+x+y*(*this->width)] *2 ;
   if((x>0)&&(y!=0)) h_x += this->buffer[i+x+y*(*this->width)] *(-1);
   if((x>0)&&(y==0)) h_x += this->buffer[i+x+y*(*this->width)] *(-2) ; 
  }
 }
 h_x=h_x/8;
 return h_x;
}

void IMAGE::invert(){}
void IMAGE::test(){}

/*
#################################
#				#
# Hilfsfunktionen		#
#				#
#################################
*/

uint16
IMAGE::SearchMax(){
 uint16 max = 0;
 for(unsigned int i=0; i<this->GetBufferSize(); i++){
  if(this->buffer[i] > max) max=this->buffer[i];
  if(max==(pow(2, this->GetBPS()) - 1)) break;
 }
// printf("\nMax= %u\n", max);
 return max;
}

uint16
IMAGE::SearchMin(){
 uint16 min = pow(2,this->GetBPS()) -1;
 for(unsigned int i=0; i<this->GetBufferSize(); i++){
  if(this->buffer[i] < min) min = this->buffer[i];
  if(min==0) break;
 }
// printf("\nMin= %u\n", min);
 return min;
}

/*### NOTIZEN ###*/
/*
-> 8er-Nachbarschaft
for(int h = 1; h < 2*H-1; h++){
 for(int w = 1; w < W-1; w++){
  for(int x = -1; x < 2; x++){
   for(int y = -1; y < 2; y++){ 

   }
  }
 }
}

*/

/*### SICHERUNG ###*/

uint16 long

Was soll das denn sein?

IMAGE::IMAGE(const IMAGE & img){
// image = TIFFOpen("newFile.tif", "w");
 bps = new uint16;
 *bps = *(img.bps);
 spp = new uint16;
 *spp = *(img.spp);
 rowsps = new unsigned long;
 *rowsps = *(img.rowsps);
 width = new uint32;
 *width = *(img.width);
 height = new uint32;
 *height = *(img.height);
 scanlineSize = new int;
 *scanlineSize = *(img.scanlineSize);
 bufferSize = new unsigned long;
 *bufferSize = *(img.bufferSize);

 buffer = new uint16[*bufferSize+1];
 for(unsigned int i=0; i < *bufferSize; i++) buffer[i] = img.buffer[i];
}

also

IMAGE::IMAGE(const IMAGE & img)
{
}

Aber was falsches kann ich nicht erkennen. Mein Compiler zeigt mir (zu Recht) tausende Fehler, weil er die Hälfte von deinen Funktionen und Klassen (der Tiff kram) natürlich nicht kennt.

habe ich irgendwo "uint16 long" stehen?

Tut mir leid, als ich deinen Beitrag gelesen hatte, war es schon zu spät
Ja ich benutze die Libtiff

Vielen Dank, dass habe ich gleich mal geändert
(weiß garnicht, warum da nicht mal eine Warnung kam)

Damit änderte sich aber leider nicht mein Problem

Zeile 310. Seh ich schon Ufos?

Möp. oO

Ich hab per Textsuche das dezent überlesen

Könnte es sein, dass du dein Projekt kompiliert hast, bevor du test() und invert() implementiert hast?

Ansonsten kann ich mir nichts anderes vorstellen was an dem Code falsch sein könnte, sodass der Compiler eine derartige Fehlermeldung ausspuckt.

Also ich habe jetzt jede einzelne Komponente (ob .h oder .cpp) gespeichert und alles nochmal versucht zu kompilieren. Aber die Fehlermeldung ist leider nach wie vor noch die selbe.

*könnte es sein, dass du test() und invert() implementiert hast, bevor du sie in der klasse deklariert hast?

Und "uint16 long" hat echt keine Fehlermeldung rausgeworfen? Welche Compiler-Version von G++ hastn?

Damit änderte sich aber leider nicht mein Problem

Wenn ich Header und Implementierung in ein File kopiere, kann ich (nachdem ich einen c'tor nach hinten in der Datei verschoben habe) alles kompilieren.

Kompilierst Du das richtige?

und ich kompiliere wie folgt:

g++ -Wall main.cpp image.cpp hist.cpp -ltiff -o ausgabe

SCHIRSCHADENDUDEL

mitten im Quelltext des Headers. Wenn das wirklich der Header ist, der eingebunden wird, fällt Dir das auf die Füsse.
(Und ich denke der gepostete Header ist nicht der, den der Compiler sieht.)