Problem beim Verwenden von 2D Arrays

Vielen Dank für die rasche Antwort.

Ich habe zwar noch nie wirklich etwas mit Selbst Inkrementierenden Zeigern gemacht, denke aber, dass so wie ich das nun eingebaut habe in die richtige richtung gehen müßte. Leider gibt mir der Compiler nun die Fehlermeldung "Ungültige Dereferenzierung" heraus, was mir sagt, dass ich da doch noch etwas recht wichtiges übersehen haben müßte. Das wundert mich insofern, da ein kleines Testprogramm mit dem ich mal diese Selbst Inkrementierenden Zeiger, an einer selbst gebastelten Matrix, ausprobierte recht gut lief.

Des weiteren erhalte ich noch eine Fehlermeldung " error C2106: '=': Linker Operand muss ein L-Wert sein" an den Stellen an denen ich die Dinge letztlich in das Kontrastarray schreiben möchte, dieser erscheint nicht wenn man es über Kontrast[m][n] anspricht, obwohl es ja, so wie ich das verstand, genau das Gleiche sein müßte wie *(*(Kontrast+m)+n) .

Ich poste hier mal den neuen Code und hoffe, auf weitere Hinweise auf das was ich noch übersehen habe/ bzw. falsch mache.

/*Programm zur Kontrastberechnung und Bildarrayzerlegung

Brows=Reihenanzahl des neuen Bildarrays (Kontrastbild) von LabVIEW errechnet und übergeben
Bcols=Kolumnenanzahl des neuen Bildarrays (Kontrastbild) von LabVIEW errechnet und übergeben
Lrows=Reihenanzahl eines Teilarrays von LabVIEW übergeben
Lcols=Kolumnenanzahl eines Teilarrays von LabVIEW übergeben
Bild=Das Bildarray des ursprünglichen Bildes welches von LabVIEW übergeben wurde
Kontrast=Errechnetes Kontrastbild welches an LabVIEW übergeben werden soll
*/



/* Call Library source file */

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

__declspec(dllexport) long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, unsigned char *Bild, double *Kontrast,long *test);


//Hauptprogramm Kontrastberechnung

double* callocvector(int);
double* freevector(double*);
double** callocmatrix(int, int);
double** freematrix(double**,int);




long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, unsigned char *Bild, double *Kontrast,long *test)
{

/*
*test=*Lrows * *Lcols;
Kontrast[1][1]=777;

return 0;
}
*/


int i=0,j=0,m=0,n=0;


double** Mittelwert = callocmatrix(*Brows,*Bcols);
//double** Kontrast = callocmatrix(*Brows,*Bcols);

// Mittelwertsberechnung
for (m=0;m<=*Brows;i++)
{
for(n=0;n<=*Bcols;n++)
{
for (i=0;i<=*Lrows;i++)
{
for(j=0;j<=*Lcols;j++)
{
//Mittelwert[m][n]=Mittelwert[m][n]+Bild[i+(m * *Lrows)][j+(n * *Lcols)];
Mittelwert[m][n]=Mittelwert[m][n]+ *( *(Bild+i+(m * *Lrows))+j+(n * *Lcols) );
}
}
Mittelwert[m][n]=( 1.0/(*Lrows * *Lcols) )* Mittelwert[m][n];
}
}





//Kontrastberechnung
for (m=0;m<=*Brows;i++)
{
for(n=0;n<=*Bcols;n++)
{
for (i=0;i<=*Lrows;i++)
{
for(j=0;j<=*Lcols;j++)
{
//Kontrast[m][n]=Kontrast[m][n]+( (Bild[i+(m * *Lrows)][j+(n * *Lcols)]-Mittelwert[m][n])
// *(Bild[i+(m * *Lrows)][j+(n * *Lcols)]-Mittelwert[m][n]) );
*(*(Kontrast+m)+n)=*(*(Kontrast+m)+n) + ( *( *(Bild+i+(m * *Lrows))+j+(n * *Lcols) )-Mittelwert[m][n])
*( *(*(Bild+i+(m * *Lrows))+j+(n * *Lcols) )-Mittelwert[m][n] );
}
}
//Kontrast[m][n]=( 1.0/(*Lrows * *Lcols) )* Kontrast[m][n];
*(*(Kontrast+m)+n)=( 1.0/(*Lrows * *Lcols) )* *(*(Kontrast+m)+n);
}
}

//Freigeben des reservierten Speichers
//Kontrast = freematrix(Kontrast,Lrows);
Mittelwert = freematrix(Mittelwert,*Lrows);
return 0;
}










//Unterprogramme zur dynamischen Speicherallokation



/*--------------------------------------------
"callocvector" allocates the memory for a
dynamic vector of length n and initializes it
--------------------------------------------*/

double* callocvector(int n)
{
int j;
double* vector = calloc(n,sizeof(double));

for (j=0; j<n; j++)
{
vector[j] = 0;
}
return(vector);
}


/*--------------------------------------------
"freevector" dis-allocates the memory of
a dynamic vector of arbitrary length and
sets the pointer to NULL
--------------------------------------------*/

double* freevector(double* vector)
{
free(vector);
return(NULL);
}



/*--------------------------------------------
"callocmatrix" allocates the memory for a
dynamic matrix of size (m times n)
and initializes it
--------------------------------------------*/

double** callocmatrix(int m, int n)
{
int i;
double** matrix = calloc(m,sizeof(double));

for (i=0; i<m; i++)
{
matrix[i] = callocvector(n);
}
return(matrix);
}


/*--------------------------------------------
"freematrix" dis-allocates the memory of
a dynamic matrix of size (m times n)
and sets the pointer to NULL
--------------------------------------------*/

double** freematrix(double** matrix,int m)
{
int i;

for (i=0; i<m; i++)
{
free(matrix[i]);
free(matrix);
}
return(NULL);
}