mein Ansatz:

freistellen(bild,2048,2048,region[420, 231, 810, 1119]);

was mache ich falsch?
Danke schonmal im voraus...

Die Programme:

/*
 *  imgproc.h
 */

#ifndef PIXEL
#define PIXEL unsigned char 
#endif

/* Strukturtyp für die Beschreibung eines Bildausschnitts */
typedef struct
{
	int x;  /* x-Koordinate (Spaltenindex) der oberen linken Ecke */
	int y;  /* y-Koordinate (Zeilenindex) der oberen linken Ecke */
	int width;  /* Breite des Bildausschnitts (#Spalten) */
	int height; /* Höhe des Bildausschnitts (#Zeilen) */
} ImageBox;

/* Funktion für einen Histogrammausgleich (Kontrastverbesserung) */
void histequ(PIXEL **bild, /* Input und Output-Bild */
			 int lines,    /* Zeilenanzahl von bild */
			 int columns   /* Spaltenanzahl von bild */
			 );

/* Funktion zur Berechnung eines Grauwerthistogramms für einen Bildausschnitt */
void histo(PIXEL **bild,
		   ImageBox region,    /* Größe und Lage des Bildausschnitts */
	       long *buff1     /* Zeiger auf Ergebnis (Datenfeld mit Länge 256) */
		   );

/* Funktion zum Extrahieren eines Bildausschnitts.
   Das Ursprungsbild wird nicht verändert.
   Der Rückgabewert ist ein Zeiger auf ein neues Bild,
   das den Ausschnitt enthält.
*/
PIXEL **freistellen(PIXEL **bild, 
					int   anzahl_zeilen,  /* Zeilenanzahl von bild */
					int   anzahl_spalten, /* Spaltenanzahl von bild */
					ImageBox region    /* Größe und Lage des Bildausschnitts */					
					); /* Breite des Ausschnitts (#Spalten) */

/* Ausgabe eines vereinfachten Bild-Histogramms als ASCII-Text auf stdout */
void histogram_print( PIXEL **bild, int zeilenanzahl, int spaltenanzahl );

/* Berechnung des kleinsten Pixelwerts im Bild. */
/* Der Rückgabewert ist der Minimum-Wert.       */
PIXEL bild_minimum(PIXEL **bild, 
				   int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				   int   anzahl_spalten /* Spaltenanzahl von bild */
                   );

/* Berechnung des größten Pixelwerts im Bild. */
/* Der Rückgabewert ist der Maximum-Wert.     */
PIXEL bild_maximum(PIXEL **bild, 
				   int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				   int   anzahl_spalten /* Spaltenanzahl von bild */
                   );

/* Faltung eines Bildes mit einem 3x3 Filterkern. */
void filter3x3 (PIXEL **bild,         /* Input und Output-Bild */
				int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				int   anzahl_spalten, /* Spaltenanzahl von bild */
				int   filter[3][3]    /* Matrix der Filterkoeffizienten */
				);

/*
 *  imgproc.c
 */

#include <stdio.h>
#include <stdlib.h>
#include "tinyjpeg.h"
#include "imgproc.h"

/*                                                                         */
/* histequ Histogramm-Equalization                                         */
/*                                                                         */
/* Parameter:                                                              */
/* ==========                                                              */
/* matr,line,columns Bilddefinition                                        */
/*                                                                         */
/***************************************************************************/

void histequ(PIXEL **matr, int lines, int columns)
{
	extern void histo();

	long buff[256];
	int i;
	PIXEL kennli[256];
	double coeff;
	 PIXEL *frpt,*le;
	 PIXEL *kk;
	ImageBox region = {0, 0, columns, lines};

	coeff = 255.0 / ((double)lines * (double)columns);

	histo(matr,region,buff);

	kennli[0] = 0;

	for (i = 1; i < 256; i++)
	{
		buff[i] += buff[i - 1];
		kennli[i] = (PIXEL)(coeff * (double)buff[i]);
	}

	kk = kennli;

	for (i = 0; i < lines; i++)
	{
		frpt = matr[i];
		le = frpt + columns;

		while (frpt < le)
		{
			*frpt = kk[*frpt];
			frpt++;
		}
	}
}

/* Funktion zur Berechnung eines Grauwerthistogramms für einen Bildausschnitt */
void histo(PIXEL **bild,
		   ImageBox region,    /* Größe und Lage des Bildausschnitts */
	       long *buff1  /* Zeiger auf Ergebnis (Datenfeld mit Länge 256) */
		   )
{
	int lines = region.height;
	int columns = region.width;
	int y_a = region.y;
	int x_a = region.x;
	int i;
	PIXEL *frpt;
	PIXEL *le;
	long *buff;
	long  val;

	buff = buff1;

	for (i = 0; i < 256; i++) buff1[i] = 0;

	for (i = 0; i < lines; i++)
	{
		frpt = bild[i + y_a] + x_a;
		le = frpt + columns;   

		while (frpt < le)
		{
			val = (*frpt++);
			*((long*)(buff + val)) += 1;
		}
	}
}

/* Funktion zum Extrahieren eines Bildausschnitts.
 Das Ursprungsbild wird nicht verändert.
 Der Rückgabewert ist ein Zeiger auf ein neues Bild,
 das den Ausschnitt enthält.
 */
PIXEL **freistellen(PIXEL **bild, 
					int   anzahl_zeilen,  /* Zeilenanzahl von bild */
					int   anzahl_spalten, /* Spaltenanzahl von bild */
					ImageBox region    /* Größe und Lage des Bildausschnitts */					
					) 
{
	PIXEL **bildausschnitt;
	int   i, j;
	int   ia, ja;
	int hoehe = region.height;
	int breite = region.width;
	int erste_zeile = region.y;
	int erste_spalte = region.x;

	if (erste_zeile+hoehe > anzahl_zeilen  ||
		erste_spalte+breite > anzahl_spalten ||
		erste_zeile < 0 || erste_spalte < 0 )
		return NULL;

	bildausschnitt = (PIXEL **) 
		pointer_array( /* address of matrix element (0,0) */
					   malloc(hoehe*breite*sizeof(PIXEL)),
					   hoehe,      /* number of rows of the matrix  */
					   breite,   /* actual number of columns, ie the distance 
							      between two consecutive row beginnings specified in units of element size. */
					   sizeof(PIXEL) /* size of the matrix elements in bytes */
					) ;
	ia = ja = 0;
	if (bildausschnitt != NULL)
		for (i=erste_zeile, ia=0; i < erste_zeile+hoehe; i++, ia++)
			for (j=erste_spalte, ja=0; j < erste_spalte+breite; j++, ja++)
				bildausschnitt[ia][ja] = bild[i][j];

	return (bildausschnitt);
}

/* Ausgabe eines vereinfachten Bild-Histogramms als ASCII-Text auf stdout */
void histogram_print( PIXEL **bild, int zeilenanzahl, int spaltenanzahl )
{   long int histo[64] = {0};
	int  i, j;
	long int max=0;
	int  pix;
	const int histo_height=15;

	printf("\nNormiertes Histogramm - Klassenbreite 4: 0...255 --> 0...63\n");
	for (j=0; j<64; j++)
		printf("-");
	printf("\n");

	for (i=0; i < zeilenanzahl; i++)
		for (j=0; j < spaltenanzahl; j++)
		{
			pix = bild[i][j]/ 4;
			if (pix < 64)
			{
			histo[pix] += 1;
			if (histo[pix] > max)
				max = histo[pix];
			}
		}

	for (i=histo_height; i >=1; i--)
	{
		for (j=0; j<64; j++)
			if ((double)histo[j]/(double)max *histo_height >= i)
				putchar('|');
	        else
		        putchar(' ');
		putchar('\n');
	}
	for (j=0; j<64; j++)
		printf("%1i", j/10);
	putchar('\n');	
	for (j=0; j<64; j++)
		printf("%1i", j%10);
	putchar('\n');	
}

/* Berechnung des kleinsten Pixelwerts im Bild. */
/* Der Rückgabewert ist der Minimum-Wert.       */
PIXEL bild_minimum(PIXEL **bild, 
				   int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				   int   anzahl_spalten /* Spaltenanzahl von bild */
                   )
{
	int   i, j;
	PIXEL pix;

	pix = bild[0][0];
	for (i=0; i < anzahl_zeilen; i++)
		for (j=0; j < anzahl_spalten; j++)
			if (bild[i][j] < pix)
				pix = bild[i][j];

	return (pix);
}

/* Berechnung des größten Pixelwerts im Bild. */
/* Der Rückgabewert ist der Maximum-Wert.     */
PIXEL bild_maximum(PIXEL **bild, 
				   int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				   int   anzahl_spalten /* Spaltenanzahl von bild */
                   )
{
	int   i, j;
	PIXEL pix;

	pix = bild[0][0];
	for (i=0; i < anzahl_zeilen; i++)
		for (j=0; j < anzahl_spalten; j++)
			if (bild[i][j] > pix)
				pix = bild[i][j];

	return (pix);
}

/* Faltung eines Bildes mit einem 3x3 Filterkern. */
void filter3x3 (PIXEL **bild,         /* Input und Output-Bild */
				int   anzahl_zeilen,  /* Zeilenanzahl von bild */
				int   anzahl_spalten, /* Spaltenanzahl von bild */
				int   filter[3][3]    /* Matrix der Filterkoeffizienten */
				)
{
	int   i, j;
	int   pix;
	int   filtersumme=0;
	PIXEL puffer[5000];

	for (i=0; i < 3; i++)
		for (j=0; j < 3; j++)
			filtersumme += filter[i][j];

	for (i=1; i < anzahl_zeilen-1; i++)
	{
		for (j=1; j < anzahl_spalten-1; j++)
		{
			pix = bild[i][j] * filter[1][1] +
			      bild[i-1][j] * filter[0][1] +
			      bild[i+1][j] * filter[2][1] +
			      bild[i][j-1] * filter[1][0] +
			      bild[i-1][j-1] * filter[0][0] +
			      bild[i+1][j-1] * filter[2][0] +
			      bild[i][j+1] * filter[1][2] +
				  bild[i-1][j+1] * filter[0][2] +
			      bild[i+1][j+1] * filter[2][2] ;

			if (filtersumme != 0)
			   pix = pix / filtersumme;
			if (pix < 0)
				puffer[j] = 0;
			else
				puffer[j] =pix;
		}
	for (j=1; j < anzahl_spalten-1; j++)	
		bild[i-1][j] = puffer[j];
	}
}

ich möchte gerne einen Bildausschnitt aus einem 2048 x 2048 Bild....
das sind die Koordinaten:
Rectangle Selection
X: 420
Y: 231
Width: 810
Height: 1119

was mach ich denn falsch? bzw wie geht das richtig?

Wenn du

region[420, 231, 810, 1119]

schreibst ist das AFAIK das selbe wie

region[1119]

histequ(bild,2048,2048);
rcode = writeGIF( "A" Matrikelnummer GIF_Extension, bild, zeilenanzahl, spaltenanzahl);

beim "freistellen" komme ich einfach nicht drauf was ich für "ImageBox region" einsetzen soll...

in der zweiten zeile wird "region" rot unterstrichen und der compiler sagt mir das es für "region" int keinen passenden Konstruktor unter "ImageBox" hat.

Schau dir an, wie du region in histequ benutzt.

In deiner Funktion histequ rufst du histo auf. Dabei brauchst du auch eine Variable vom Typ ImageBox.
Die Art und Weise wie du das da machst, sollst du dir ansehen.

meinst du so`?

freistellen(bild, 2048, 2048,region{420, 231, 810, 1119});

der sagt mir immernoch "kein passender konstruktor vorhanden"

Nein!

Da benutzt du eine extra Variable, so wie DarkShadow44 es schon vorgeschlagen hat.

Machst du in deinem Programm (da wo du freistellen aufrufst) auch ein #include "imgproc.h"?

#include <stdio.h>
#include <stdlib.h>

#include "writeGIF.h"     /* Deklarationen für die GIF-Routinen */
#include "loadjpeg.h"     /* Deklarationen für die JPEG-Routinen */
#include "imgproc.h"      /* Deklarationen für die Bildverarbeitungsroutinen */

/* Name für das Testbild */
#define TestBild       "Foto"
#define Matrikelnummer "123456"
#define JPG_Extension  ".jpg"
#define GIF_Extension  ".gif"
#define TestBild_In    TestBild JPG_Extension

	if ( rcode != 0 )
	{
		fprintf( stderr, "Fehler beim Schreiben der GIF-Datei!\n");
		return (1);
	}

OK jetzt ist die fehlermeldung weg der speichert mir immernoch nicht den "ausschnitt" den ich gern hätte.

/* Funktion zum Extrahieren eines Bildausschnitts. 
   Das Ursprungsbild wird nicht verändert. 
   Der Rückgabewert ist ein Zeiger auf ein neues Bild, 
   das den Ausschnitt enthält. 
*/ 
PIXEL **freistellen(PIXEL **bild, 
                    int   anzahl_zeilen,  /* Zeilenanzahl von bild */ 
                    int   anzahl_spalten, /* Spaltenanzahl von bild */ 
                    ImageBox region    /* Größe und Lage des Bildausschnitts */                 
                    ); /* Breite des Ausschnitts (#Spalten) */

Außerdem müsstest du beim speichern die spalten und Zeilenanzahl des neuen Abschnitts angeben, nicht die des originals!

... der speichert mir immernoch nicht den "ausschnitt" den ich gern hätte.

bizbo schrieb:

rcode = writeGIF( "A" Matrikelnummer GIF_Extension, bild, zeilenanzahl, spaltenanzahl);
 
   
 
    ImageBox gregion = {420, 231, 810, 1119};
    freistellen(bild, 2048, 2048,gregion);
    rcode = writeGIF( "B" Matrikelnummer GIF_Extension, bild, zeilenanzahl, spaltenanzahl);

Schau dir da mal die erste und letzte Zeile an.
Worin unterscheiden die sich?
Nur in dem ersten Zeichen für den Dateinamen. Und da wunderst du dich, dass du das gleiche Bild bekommst.

Aus deiner imgproc.h:

imgproc.h schrieb:

/* Funktion zum Extrahieren eines Bildausschnitts.
   Das Ursprungsbild wird nicht verändert.
   Der Rückgabewert ist ein Zeiger auf ein neues Bild,
   das den Ausschnitt enthält.
*/
PIXEL **freistellen(PIXEL **bild,
                    int   anzahl_zeilen,  /* Zeilenanzahl von bild */
                    int   anzahl_spalten, /* Spaltenanzahl von bild */
                    ImageBox region    /* Größe und Lage des Bildausschnitts */                
                    ); /* Breite des Ausschnitts (#Spalten) */

Der Kommentar vor der Funktionsdeklaration steht da nicht ohne Grund.

Und nach dem Freistellen hat das Bild auch ein andere Größe.

Ach, und der Titel Pointer geht nicht ist falsch. Du hast Probleme mit einer struct .
Aber das wird noch.

Könntet Ihr mir vielleicht anstatt Gedankenstupser einen Stoß verpassen?

ImageBox gregion = {1119, 810, 231, 420};
	PIXEL **bildneu=freistellen(bild, 2048, 2048,gregion);
	rcode = writeGIF( "B" Matrikelnummer GIF_Extension, bildneu, 1119, 810);

Merkst du was ?