Problem beim Verwenden von 2D Arrays

Hallo,

ich möchte aus LV in ein C Programm ein 2D Array einlesen, daraus Berechnungen anstellen und die Ergebnisse anschließend in ein neues 2D Array schreiben, das dann wieder an LV übergeben werden soll.
Leider scheint es jedoch mit diesen 2D Arrays Probleme zu geben, denn immer wenn ich sie im C Programm anspreche gibt LV einen fehler heraus, mache ich testweise nur eine Berechnung mit den anderen übergebenen Werten funktioniert dies und ich erhalte keinen Fehler.

Meine Funktion lautet folgendermaßen:
long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, unsigned char **Bild, double **Kontrast,long *test)

Brows,Bcols geben die Größe des neuen 2D Arrays "Kontrast" an.
Lcols und Lrows geben an in wie große, ich nenne es mal, Teilarrays das ursprüngliche 2D Array "Bild" zerlegt werden soll, was für die Berechnung wichtig ist aber auch für die Größe des neuen Ausgangsarrays. test ist einfach nur eine Variable die ich zum testen einfacher berechnung ohne Arrays verwendete.

LabVIEW schlägt als Funktionsprototyp übrigens folgendes vor:
long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, unsigned char *Bild, double *Kontrast,long *test)
Das erscheint mir und dem Kompiler jedoch als sehr unsinnig da definitiv ein 2D Array eingestellt wurde.

Als Array Datentyp wurde übrigens "Array Datenzeiger" bei den beiden 2D Arrays Kontrast und Bild eingesetzt.


Der C-Code lautet:


/*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]=( 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++)
{
Mittelwert[m][n]=Mittelwert[m][n]+Bild[i+(m * *Lrows)][j+(n * *Lcols)];
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];
}
}

//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);
}