static int find_regional_maxima (unsigned short numrows,
unsigned short numcols,
simple_REGION_list **mr_first,
simple_REGION_list **mr_last,
short *num_regions,
double **greyvalues)
{
/*******************************************************************/
/* Es werden Listen von regionalen Maxima erzeugt */
/*******************************************************************/
unsigned short row;
unsigned short col;
short maxflag;
short ind_plateau;
simple_PIXEL_list *currpix;
simple_REGION_list *last_but_one = NULL;
unsigned char **vis;
vis = (unsigned char **) matrix_all_alloc (numrows, numcols, 'U', 0);
new_region_in_region_list (mr_first, mr_last);
*num_regions = 0;
for (row = 0; row < numrows; row ++)
{
//#pragma omp parallel for
for (col = 0; col < numcols; col ++)
{
if (vis [row][col] != 0)
continue;
maxflag = 1;
ind_plateau = 0;
single_check_neighbours (numrows, numcols, row, col, greyvalues, &maxflag, &ind_plateau);
/*************************************************************/
/* Das aktuelle Pixel der Schleife wird hier als besucht */
/* markiert, auch wenn es das erste Pixel eines Plateaus */
/* ist (die uebrigen Pixel des Plateaus werden dann in */
/* check_plateau_us markiert). */
/*************************************************************/
vis [row][col] = 1;
if (ind_plateau == 0)
{
/**********************************************************/
/* Kein Nachbarpixel hat denselben Grauwert wie das */
/* aktuelle Pixel */
/**********************************************************/
if (maxflag == 1)
{
/*******************************************************/
/* Ein Maximum, bestehend aus einem einzigen Pixel */
/*******************************************************/
last_but_one = *mr_last;
new_pixel_in_region (*mr_last, row, col);
(*num_regions) ++;
new_region_in_region_list (mr_first, mr_last);
}
else
{
;
/*******************************************************/
/* Kein Maximum, da tun wir gar nichts */
/*******************************************************/
}
continue;
}
/*************************************************************/
/* Es ist ein Plateau */
/*************************************************************/
new_pixel_in_region (*mr_last, row, col);
//#pragma omp parallel for
for (currpix = (*mr_last) -> first; currpix != NULL; currpix = currpix -> next)
{
check_plateau (numrows, numcols, greyvalues, vis, *mr_last, currpix, &maxflag);
}
if (maxflag == -1)
free_pixlist_of_region (*mr_last);
else
{
/**********************************************************/
/* Ein neues Maximum-Plateau */
/**********************************************************/
last_but_one = *mr_last;
new_region_in_region_list (mr_first, mr_last);
(*num_regions) ++;
}
}
}
free_last_region (mr_first, mr_last, last_but_one);
matrix_all_free ((void **) vis);
return 0;
}
bool Cconnectivity_analysis::On_Execute(void)
{
CSG_Grid *pinpgrid, *bingrid, *symb_grid, *hgrid;
CSG_Shapes *pOutlines;
bool filter, corners_centers, remove_marginal_regions;
unsigned short numrows;
unsigned short numcols;
unsigned char center;
double xmin;
double ymin;
short interm_grid_created;
simple_REGIONC_list *reg_first;
simple_REGIONC_list *reg_last;
simple_REGIONC_list *reg_curr;
pinpgrid = Parameters ("INPUT_GRID")->asGrid();
bingrid = Parameters ("FILTERED_MASK")->asGrid();
filter = Parameters ("FILTER")->asBool();
corners_centers = Parameters ("BORDER_PIXEL_CENTERS")->asBool();
remove_marginal_regions = Parameters ("REMOVE_MARGINAL_REGIONS")->asBool();
pOutlines = Parameters("OUTLINES")->asShapes();
symb_grid = Parameters ("SYMBOLIC_IMAGE")->asGrid();
CSG_String sName = pOutlines->Get_Name();
pOutlines->Destroy();
pOutlines->Set_Name(sName);
pOutlines->Add_Field(SG_T("ID"), SG_DATATYPE_Int);
numrows=pinpgrid->Get_NY()+2;
numcols=pinpgrid->Get_NX()+2;
// xmin=pinpgrid->Get_XMin()-2*pinpgrid->Get_Cellsize();
// ymin=pinpgrid->Get_YMin()-2*pinpgrid->Get_Cellsize();
xmin=pinpgrid->Get_XMin();
ymin=pinpgrid->Get_YMin();
unsigned char **bin_image;
long **symb_image;
if (corners_centers)
center = 1;
else
center = 0;
bin_image = (unsigned char **) matrix_all_alloc (numrows, numcols, 'U', 0);
symb_image = (long **) matrix_all_alloc (numrows, numcols, 'L', 0);
interm_grid_created = 0;
//SG_Free(bin_image);
//CSG_Grid *pTmp = new CSG_Grid();
//delete pTmp;
if (filter)
{
if (bingrid == NULL)
{
SG_UI_Msg_Add(_TL("Filtered mask will be created automatically ..."), true);
bingrid = SG_Create_Grid(SG_DATATYPE_Char,
pinpgrid->Get_NX(),
pinpgrid->Get_NY(),
pinpgrid->Get_Cellsize(),
pinpgrid->Get_XMin(),
pinpgrid->Get_YMin());
if (bingrid == NULL)
{
SG_UI_Msg_Add_Error(_TL("Unable to create filtered mask grid!"));
matrix_all_free ((void **) bin_image);
matrix_all_free ((void **) symb_image);
return (false);
}
Parameters("FILTERED_MASK")->Set_Value(bingrid);
interm_grid_created = 1;
}
//-----------------------------------------------------
RUN_MODULE("grid_filter" , 13,
SET_PARAMETER("INPUT_GRID" , pinpgrid)
&& SET_PARAMETER("OUTPUT_GRID" , bingrid)
&& SET_PARAMETER("RADIUS" , Parameters ("SIZE")->asInt())
)
hgrid = bingrid;
}
else
{
hgrid = pinpgrid;
}
for (int y = 0; y < hgrid->Get_NY () && Set_Progress(y, hgrid->Get_NY()); y++)
{
for (int x = 0; x < hgrid->Get_NX(); x++)
{
if (hgrid->is_NoData(x,y))
bin_image[y+1][x+1] = 0;
else
bin_image[y+1][x+1] = hgrid->asChar(x,y);
}
}
// Here the regions are removed which have contact with the image margins;
// this is achieved by a region growing
if (remove_marginal_regions)
{
for (int y = 1; y < numrows - 1; y++)
{
if (bin_image [y][1] != 0)
background_region_growing (bin_image, numrows, numcols, y, 1);
if (bin_image [y][numcols - 2] != 0)
background_region_growing (bin_image, numrows, numcols, y, numcols-2);
}
for (int x = 1; x < numcols - 1; x++)
{
if (bin_image [1][x] != 0)
background_region_growing (bin_image, numrows, numcols, 1, x);
if (bin_image [numrows-2][x] != 0)
background_region_growing (bin_image, numrows, numcols, numrows-2, x);
}
if (filter)
{
for (int y = 0; y < bingrid->Get_NY (); y++)
{
#pragma omp parallel for
for (int x = 0; x < bingrid->Get_NX(); x++)
{
bingrid->Set_Value(x, y, bin_image[y+1][x+1]);
}
}
}
}
if (interm_grid_created)
bingrid->Destroy();
// The function which does the proper work:
// computation of the symbolic image, construction of the border chains (shapes)
comb_contour_region_marking (numrows,
numcols,
bin_image,
symb_image,
®_first,
®_last,
center);
for (int y = 0; y < symb_grid->Get_NY () && Set_Progress(y, symb_grid->Get_NY()); y++)
{
#pragma omp parallel for
for (int x = 0; x < symb_grid->Get_NX(); x++)
{
symb_grid->Set_Value(x, y, symb_image[y+1][x+1]);
}
}
// Here the shapes are generated
int iPolygon;
for (iPolygon = 0, reg_curr = reg_first; reg_curr != NULL; reg_curr = reg_curr -> next, iPolygon++)
{
CSG_Shape *pShape = pOutlines->Add_Shape();
pShape->Set_Value(0, iPolygon); // set ID field (= first field in table) to polygon ID
for (simple_PIXELC_list *pix_curr = reg_curr->first_pix; pix_curr != NULL; pix_curr = pix_curr->next)
{
TSG_Point point = symb_grid->Get_System().Get_Grid_to_World(pix_curr->col - 1, pix_curr->row - 1);
pShape->Add_Point(point, 0);
}
int iHoles;
simple_INNER_REGION_list *inner_curr;
for (iHoles=0, inner_curr = reg_curr->inner_first;
iHoles < reg_curr->num_holes;
iHoles++, inner_curr = inner_curr->next)
{
for (simple_PIXELC_list *pix_curr = inner_curr->first_pix; pix_curr != NULL; pix_curr = pix_curr->next)
{
TSG_Point point = symb_grid->Get_System().Get_Grid_to_World(pix_curr->col - 1, pix_curr->row - 1);
pShape->Add_Point(point, iHoles+1);
}
}
if (!corners_centers)
shift_shape (pShape, -Get_Cellsize()/2.0, -Get_Cellsize()/2.0);
}
matrix_all_free ((void **) bin_image);
matrix_all_free ((void **) symb_image);
free_regions (®_first, ®_last);
return( true );
}
bool Cbin_erosion_reconst::On_Execute(void)
{
CSG_Grid *pinpgrid, *bingrid, *poutgrid;
unsigned short numrows;
unsigned short numcols;
char **mask;
char **marker;
pinpgrid = Parameters ("INPUT_GRID")->asGrid ();
poutgrid = Parameters ("OUTPUT_GRID")->asGrid ();
numrows=pinpgrid->Get_NY();
numcols=pinpgrid->Get_NX();
// bingrid is not an output grid here, so it must be created ad hoc
bingrid = SG_Create_Grid(SG_DATATYPE_Char,
pinpgrid->Get_NX(),
pinpgrid->Get_NY(),
pinpgrid->Get_Cellsize(),
pinpgrid->Get_XMin(),
pinpgrid->Get_YMin());
if (bingrid == NULL)
{
SG_UI_Msg_Add_Error(_TL("Unable to create grid for the eroded image!"));
return (false);
}
RUN_TOOL("grid_filter" , 8,
SET_PARAMETER("INPUT" , pinpgrid)
&& SET_PARAMETER("RESULT" , bingrid)
&& SET_PARAMETER("MODE" , 1)
&& SET_PARAMETER("RADIUS" , Parameters ("RADIUS")->asInt())
&& SET_PARAMETER("METHOD" , 1)
)
mask = (char **) matrix_all_alloc (numrows, numcols, 'C', 0);
marker = (char **) matrix_all_alloc (numrows, numcols, 'C', 0);
for (int y = 0; y < numrows; y++)
{
#pragma omp parallel for
for (int x = 0; x < numcols; x++)
{
if (pinpgrid->is_NoData(x,y)) // check if there are no_data in input datasets
{
mask [y][x] = 0;
marker [y][x] = 0;
}
else
{
mask [y][x] = pinpgrid->asChar(x,y);
marker [y][x] = bingrid->asChar(x,y);
}
}
}
bingrid->Destroy();
binary_geodesic_morphological_reconstruction (numrows, numcols, mask, marker);
for (int y = 0; y < Get_NY () && Set_Progress(y, Get_NY()); y++)
{
#pragma omp parallel for
for (int x = 0; x < Get_NX (); x++)
{
if (pinpgrid->is_NoData(x,y))
poutgrid->Set_NoData(x,y);
else
poutgrid->Set_Value(x,y, marker[y][x]);
}
}
matrix_all_free ((void **) mask);
matrix_all_free ((void **) marker);
return( true );
}
bool Ckff_synthesis::On_Execute(void)
{
CSG_Grid *poutgrid;
int numlat = 0;
int numlong = 0;
int maxdegree = 0;
int mindegree = 0;
int rc = 0;
double inc = 0.0;
double lat_start = 0.0;
double end_lat = 0.0;
double long_start = 0.0;
double end_long = 0.0;
CSG_String fileName;
double **c_lm;
double **s_lm;
double **gitter;
char *error_liste = "nix";
//poutgrid = Parameters ("OUTPUT GRID")->asGrid ();
fileName = Parameters("FILE")->asString();
inc = Parameters ("INC")->asDouble ();
mindegree = Parameters ("MINDEGREE")->asInt ();
maxdegree = Parameters ("MAXDEGREE")->asInt ();
lat_start = Parameters ("LAT_START")->asDouble ();
end_lat = Parameters ("END_LAT")->asDouble ();
long_start = Parameters ("LONG_START")->asDouble ();
end_long = Parameters ("END_LONG")->asDouble ();
numlat = static_cast <int> (floor ((end_lat - lat_start) / inc) + 1);
numlong = static_cast <int> (floor ((end_long - long_start) / inc) + 1);
gitter = (double **) matrix_all_alloc (numlat, numlong, 'D', 0);
read_coefficients (fileName.b_str(),
mindegree,
maxdegree,
&c_lm,
&s_lm);
rc = kff_synthese_regel_gitter_m (inc,
lat_start,
end_lat,
long_start,
end_long,
numlat,
numlong,
'A',
mindegree,
maxdegree,
c_lm,
s_lm,
gitter,
&error_liste);
poutgrid = SG_Create_Grid(SG_DATATYPE_Double, numlong, numlat, inc, long_start, lat_start);
poutgrid ->Set_Name(_TL("Synthesized Grid"));
for (int y = 0; y < numlat; y++)
{
#pragma omp parallel for
for (int x = 0; x < numlong; x++)
{
poutgrid->Set_Value(x,y, gitter[y][x]);
}
}
Parameters("OUTPUT_GRID")->Set_Value(poutgrid);
matrix_all_free ((void **) gitter);
matrix_all_free ((void **) c_lm);
matrix_all_free ((void **) s_lm);
return( true );
}
