Struckt probleme :(



  • Hallo habe folgendes Problem:
    Ich möchte gerne die Funktion "freistellen" benutzen....

    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];
    	}
    }
    


  • region[420, 231, 810, 1119] macht sicher nicht das, was du willst



  • stimmt 😞

    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?



  • Schau dir an, wie du region in histequ benutzt.



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

    Wenn du

    region[420, 231, 810, 1119]
    

    schreibst ist das AFAIK das selbe wie

    region[1119]
    


  • bei histequ geb ich einfach "bild und größe" an und es klappt,

    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...



  • @darkshadow

    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.



  • DirkB schrieb:

    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.



  • @dirk danke dir aber ich kriege es leider immernoch nicht hin...

    meinst du so`?

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

    der sagt mir immernoch "kein passender konstruktor vorhanden"



  • Machst du das so in histequ?

    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"?



  • schaut aktuell so aus....

    #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.



  • Ja weil du den Rückgabewert von freistellen nicht nutzt und das alte Bild abspeicherst...
    Schau dir nochmal die Funktion an:

    /* 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!



  • bizbo schrieb:

    ... 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.



  • Tja, da habe ich vieel zu lange geschrieben 😃
    (über fünf Minuten 🙄 )

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



  • vielen Dank für eure Gedult mit mir, da ich jetzt schon einige Zeit daran sitze kann ich nicht mehr klar denken.

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



  • PIXEL ** bildNeu = freistellen(/* ...*/);
    writeGIF( "A" Matrikelnummer GIF_Extension, bildNeu, /*neue zeilenanzahl*/, /*neue spaltenanzahl*/);
    


  • Vielen Dank 🙂 also der compiler zeigt keine Fehler, aber wenn ich auf debuggen gehe, stürzt das programm ab o.O ???

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


  • ImageBox gregion = {/*x:*/ 1119, /*y:*/ 810, /*spaltenanzahl:*/ 231, /*zeilenanzahl:*/ 420};
    // ...
    rcode = writeGIF( "B" Matrikelnummer GIF_Extension, bildneu, /*zeilenanzahl:*/ 1119, /*spaltenanzahl:*/ 810);
    

    Merkst du was ? 😃



  • Alter schwede.... viiiiieeeeeelllen Dank Mann.....


Log in to reply