G
Also die Idee dahinter ist, dass man ein Bild hat, dieses Bild wird in Teilarrays zerlegt, deren Größe von Lcols bzw. Lrows angegeben wird.
In jedem dieser Teilarrays wird zuallererstz der Mittelwert berechnet, anschließend die Standardabweichung. Wenn man nun die Standardabweichung durch den mittelwert dividiert erhält man daraus den Kontrast. diese Zeile fehlte übrigens bisher noch, wie ich gerade sah, daher habe ich das Programm nochmals mitgeschickt.
Diese Werte werden dann also in einem neuen Array gespeichert, dass eben entsprechend der Teilarraygrößen kleiner ist, floor(numrow/ *Lrows).
Die jeweils vier Schleifen dienen also nun dazu, das gesamte Bils zu durchwandern, was die äußeren Beiden besorgen, die inneren beiden durchlaufen dann eben diese kleinen Teilarrays.
Wenn wir annehmen, dass Lcols 2 wäre und die Indexformel j+(n*Lcols) haben wäre das also j+ (n*2)
n=0 0+0 =0
1+0=1
n=1 0+2=2
1+2=3
usw
Also ich meine, dass das so funktionieren müßte.
Ich habe nun übrigens mal die funktionszeile, so geändert, dass gar keine Sterne mehr vorhanden sind.
long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, TD1Hdl Bild, TD1Hdl Kontrast,long *test)
Tatsächlich scheint somit auch alles zu laufen. Nun zeigt sich allerdings ein viel größeres Problem. Urspünglich sollte das aus LV ausgelagert werden um diese Kontrastberechnung zu beschleunigen. Nun da ich die Berechnung in LV und die in C parallel laufen habe ist es jedoch so, dass das ganze Programm wahnsinnig verlangsamt wurde, das geht so weit, dass LV schon gar keine Rückmeldung mehr gibt.
Das ist nun doch sehr frustrierend wie ich sagen muß, ist mein Code nun wirklich so viel schlechter als das was ich in LV machte, dabei hörte ich immer, dass es doch erhebliche Geschwindigkeitsgewinne bringen sollte.
Läuft das nun nur scheinbar und es sind immernoch große Fehler enthalten, ist der code nur unglaublich schlecht aber die LV eigenen DLLs werden es doch kaum anders lösen, wie ist das nun zu erklären udn wie bekomme ich es damit nun wirklich verschnellert und nicht verlangsamt?
/*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>
#include <math.h>
#ifdef __cplusplus
extern "C" {
#endif
/* LabVIEW created typedef */
typedef struct {
int32 dimSizes[2];
double elt[1];
} TD1;
typedef TD1 **TD1Hdl;
double* callocvector(int);
double* freevector(double*);
double** callocmatrix(int, int);
double** freematrix(double**,int);
_declspec(dllexport) long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, TD1Hdl Bild, TD1Hdl Kontrast,long *test);
#ifdef __cplusplus
} // extern "C"
#endif
//Hauptprogramm Kontrastberechnung
long KontrastC(long *Brows, long *Bcols, long *Lcols, long *Lrows, TD1Hdl Bild, TD1Hdl Kontrast,long *test)
{
double** Mittelwert = callocmatrix(*Brows,*Bcols);
int i=0,j=0,m=0,n=0;
/* dimSizes[0] is the number of rows */
int numrow = (*Bild)->dimSizes[0];
/* dimSizes[1] is the number of columns */
int numcol = (*Bild)->dimSizes[1];
numrow=floor(numrow / *Lrows);
numcol=floor(numcol / *Lcols);
//(*Kontrast)->elt[(3*numcol)+2]=(*Bild)->elt[(3*numcol)+2]*1000;
durch den
// Mittelwertsberechnung
for (m=0;m<numrow;i++)
{
for(n=0;n<numcol;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)->elt[((i+(m * *Lrows))*numcol) + (j+(n * *Lcols))] ;
}
}
Mittelwert[m][n]=( 1.0/(*Lrows * *Lcols) )* Mittelwert[m][n];
(*Kontrast)->elt[(m*numcol)+n]=Mittelwert[m][n];
}
}
//Kontrastberechnung
for (m=0;m<numrow;i++)
{
for(n=0;n<numcol;n++)
{
for (i=0;i<*Lrows;i++)
{
for(j=0;j<*Lcols;j++)
{
(*Kontrast)->elt[(m*numcol)+n]= (*Kontrast)->elt[(m*numcol)+n] + ( ((*Bild)->elt[((i+(m * *Lrows))*numcol) + (j+(n * *Lcols))]-Mittelwert[m][n])
*( (*Bild)->elt[((i+(m * *Lrows))*numcol) + (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)->elt[(m*numcol)+n]=( 1.0/(*Lrows * *Lcols) )* (*Kontrast)->elt[(m*numcol)+n];
(*Kontrast)->elt[(m*numcol)+n]=(*Kontrast)->elt[(m*numcol)+n]/Mittelwert[m][n];
//Kontrast[m][n]=( 1.0/(*Lrows * *Lcols) )* *(*(Kontrast+m)+n);
}
}
//Freigeben des reservierten Speichers
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);
}