Ich versuche momentan Bitmaps oder TGAs mittels C++ einzulesen, um aus den Datein die Grauwerte für jeden Pixel bestimmen zu können.

Nun habe ich den netten TGA Loader auf dieser Seite gefunden:
http://gpwiki.org/index.php/LoadTGACpp

Ich möchte eine Datei test.tga einlesen.

wenn ich mir nun einen

char* filename = "test.tga"

definiere folgenden Code verwende:

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <cstring>
#include <sstream>
#include <vector>
#include "BMP_Read.h"
#include "TGA_load.h"
#include "memory.h"
using namespace std;

int main(int argc, char *argv[])
{
		//Für das Laden von TGAs
		TGAImg Ausgangsbild;
		char * filename = "\test.tga";
		Ausgangsbild.Load(filename);
		cout << Ausgangsbild.Load(filename)<< endl;
		int w = Ausgangsbild.GetWidth();
		cout << w << endl;

}

Dann erhalte ich leider immer die Fehlermeldung, dass das Bild nicht existieren würde.
Weiß jemand was genau ich der Klasse übergeben müsste um eine solche Datei ordentlich zu laden? Die Adresse der test.tga lautet:
F:\Sascha\Eigene Dateien\Studium\Inline_holographie\test.tga

Ich wäre euch für Hilfe sehr sehr dankbar!!!

#define IMG_ERR_NO_FILE     0x2

. Vielleicht hat jemand den TGA Loader schonmal benutzt?

const char* filename = "F:/Sascha/Eigene Dateien/Studium/Inline_holographie/test.tga";

Oder du sorgst dafür, dass dein indirekter Pfad stimmt...

Nun möchte ich gerne aus den einzelnen Elementen des char* einen intwert berechnen. Dazu müsste ich aber wissen, wie diese Elemente überhaupt gespeichert sind. Hat jemand eine Idee wie sich jedes char* Element in eine integer-Zahl umrechnen ließe?

Die Load Funktion sieht so aus:

char* TGA_Img :: Load(const char *filename)
{
		long lSize;
		int dummy,i;
		size_t results;
		char* buffer;
		FILE *picture_in;
		picture_in = fopen(filename, "rb" ); 
		fseek (picture_in, 0 , SEEK_END);
		lSize = ftell (picture_in);
		rewind (picture_in);
		buffer = (char*) malloc (sizeof(char)*lSize);
		results = fread( buffer,1, 1000, picture_in );
		return buffer;
}

Der entsprechende Teil in der main so:

//Für das Laden von TGAs
	TGA_Img Ausgangsbild;
	const char* filename = "F:/Sascha/Eigene Dateien/Studium/Inline_holographie/test.tga";
	int p=1002;
	char* buffer;
	vector <int> vc_data;
	int i;
	buffer = Ausgangsbild.Load(filename);

Mein Ziel ist es, die Werte des Headers auslesen zu könen und alle Grauwerte ine iner n kreuz m Matrix zu speichern, wobei jedes Matrixelement einen Pixel darstellen soll.

Hat jemand eine Idee wie sich jedes char* Element in eine integer-Zahl umrechnen ließe?

Warum nimmst du nicht einen std::vector in den du alles zusammen reinpackst, d.h. den ganzen Dateininhalt? Und std::fstreams für die streams, dann wirds recht einfach, den kompletten Inhalt in einem Rutsch in den vctor zu packen, ohne großartige C-Style buffer-Fummeleien wie du sie hast. An Stelle eines char-vectors kannst du dann eventuell gleich ints aus der Datei rauslesen, je nachdem wie die genau aufgebaut ist.

Achja: Mir ist das immernoch nicht klar

Ich hatte erst vor fstream zu nutzen, mir war aber nicht klar, wie ich mit fstream eine Datei in Blöcke von 1 byte aufspalten kann und dann jeden Block also jedes Byte in ein Vektorelement schreibe.

Warum solltest du das tun wollen?

?! wenn ich meine Datei einlese und mir z.B mit cout das 50te Element des Buffers ausgeben lasse, so erhalte ich nix bzw die Sonderzeichen, denen das Element in ascii gerade entspricht. Das will ich aber nicht. Das Byte stellt ja keinen Text sondern einen Wert da. Wenn ich irgendwie den Wert erfahren kann, den das Byte repräsentiert, so bin ich vollends zufrieden.

Du lässt dir also binäre Daten als Text anzeigen und bist mit dem Ergebnis nicht zufrieden. Was hast du denn erwartet?

std::cout << int(buffer[49]);

Gefällt dir dieses Ergebnis besser?

Intern ist das wurscht, es ist nur die Ausgabe die du nicht richtig gemacht hast.

Ich definiere mir einen Vektor mit int Einträgen und initialisiere diesen mittels einer void Funktion. Nun will ich zwei Einträge aus dem vektor auslesen und an andere Integerwerte übergeben. Das ganze Sieht so aus:

vector <int> vi_header[9]; 
		header_build(filename, buffer, vi_header[9]);
		int heigh, width;
		heigh = vi_header[7];
		width = vi_header[6];

Nun erhalte ich folgende Fehlermeldung:

tga_gray_load.h(75) : error C2440: '=': 'std::vector<_Ty>' kann nicht in 'int' konvertiert werden
1> with
1> [
1> _Ty=int
1> ]
1> Kein benutzerdefinierter Konvertierungsoperator verfügbar, der diese Konvertierung durchführen kann, oder der Operator kann nicht aufgerufen werden

Was soll mir das denn nun schon wieder sagen? wieso kann ich denn nicht einfache intwerte aus dem Vektor auslesen?

vector <int> vi_header[9];

Das ist ein array aus 9 vectoren. Soll vermutlich so aussehen:

vector <int> vi_header(9);

Angenommen ich möchte das erste Byte auf den Wert 118 setzen. Weiß jemand wie ich dieses schaffe?

std::ofstream stream( "test.bmp", std::ios::binary | std::ios::out );
stream.put( 118 );
stream.close();