//---------------------------------------------------------
void CData_Source_PgSQL::Append_Table(const wxTreeItemId &Parent, const SG_Char *Name, int Type, int Image)
{
CData_Source_PgSQL_Data *pData = Parent.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Parent) : NULL; if( pData == NULL ) return;
wxTreeItemId Item = AppendItem(Parent, Name, Image, Image, new CData_Source_PgSQL_Data(Type, Name, pData->Get_Server()));
if( Type == TYPE_GRIDS )
{
CSG_Table Grids;
RUN_MODULE(DB_PGSQL_Table_Query, false, // CTable_Query
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , Name)
&& SET_PARAMETER("TABLE" , &Grids)
&& SET_PARAMETER("FIELDS" , SG_T("rid, name"))
);
if( bResult )
{
for(int i=0; i<Grids.Get_Count(); i++)
{
AppendItem(Item, Grids[i].asString(1), IMG_GRID, IMG_GRID,
new CData_Source_PgSQL_Data(TYPE_GRID, CSG_String::Format("%s:rid=%d", Name, Grids[i].asInt(0)), pData->Get_Server())
);
}
}
}
}
//---------------------------------------------------------
bool CData_Source_PgSQL::Source_Drop(const wxTreeItemId &Item)
{
static wxString Username = "******", Password = "******";
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return( false );
if( !DLG_Login(Username, Password, _TL("Drop Database")) )
{
return( false );
}
pData->Set_Username(Username);
pData->Set_Password(Password);
if( pData->Get_Type() == TYPE_SOURCE && pData->is_Connected() )
{
RUN_MODULE(DB_PGSQL_DB_Drop, true, // CDatabase_Drop
SET_PARAMETER("PG_HOST", pData->Get_Host ())
&& SET_PARAMETER("PG_PORT", pData->Get_Port ())
&& SET_PARAMETER("PG_NAME", pData->Get_DBName ())
&& SET_PARAMETER("PG_USER", pData->Get_Username())
&& SET_PARAMETER("PG_PWD" , pData->Get_Password())
);
return( bResult );
}
return( false );
}
//---------------------------------------------------------
void CData_Source_PgSQL::Update_Source(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
if( pData->Get_Type() != TYPE_SOURCE )
{
return;
}
Freeze();
DeleteChildren(Item);
//-----------------------------------------------------
if( !pData->is_Connected() )
{
SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Normal);
SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Selected);
}
else
{
SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Normal);
SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Selected);
CSG_Table Tables;
RUN_MODULE(DB_PGSQL_Table_List, false, // CTable_List
SET_PARAMETER("CONNECTION", pData->Get_Value())
&& SET_PARAMETER("TABLES" , &Tables)
);
Tables.Set_Index(1, TABLE_INDEX_Ascending, 0, TABLE_INDEX_Ascending);
for(int i=0; i<Tables.Get_Count(); i++)
{
CSG_String s(Tables[i].asString(1));
TSG_Shape_Type Shape;
TSG_Vertex_Type Vertex;
if( CSG_Shapes_OGIS_Converter::to_ShapeType(s, Shape, Vertex) )
{
switch( Shape )
{
case SHAPE_TYPE_Point: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINT ); break;
case SHAPE_TYPE_Points: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINTS ); break;
case SHAPE_TYPE_Line: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_LINE ); break;
case SHAPE_TYPE_Polygon: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POLYGON); break;
}
}
else if( !s.Cmp("RASTER" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_GRIDS , IMG_GRIDS );
else if( !s.Cmp("TABLE" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_TABLE , IMG_TABLE );
}
Expand(Item);
}
Thaw();
}
//---------------------------------------------------------
void CData_Source_PgSQL::Update_Sources(const wxTreeItemId &Root)
{
Freeze();
//-----------------------------------------------------
wxTreeItemIdValue Cookie; wxTreeItemId Item = GetFirstChild(Root, Cookie);
while( Item.IsOk() )
{
Update_Source(Item);
Item = GetNextChild(Item, Cookie);
}
//-----------------------------------------------------
CSG_Table Connections;
RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections
for(int i=0; i<Connections.Get_Count(); i++)
{
if( !Find_Source(Connections[i].asString(0)) )
{
Update_Source(Connections[i].asString(0));
}
}
//-----------------------------------------------------
SortChildren(Root);
Expand (Root);
Thaw();
}
//---------------------------------------------------------
void CData_Source_PgSQL::Table_Rename(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
wxString Name = GetItemText(Item);
switch( pData->Get_Type() )
{
//-----------------------------------------------------
case TYPE_GRID:
if( DLG_Get_Text(Name, _TL("Rename Raster Band"), _TL("Name")) )
{
CSG_String Table = pData->Get_Value().BeforeFirst(':');
CSG_String rid = pData->Get_Value().AfterFirst (':');
CSG_String SQL = "UPDATE \"" + Table + "\" SET name='" + CSG_String(&Name) + "' WHERE " + rid + ";";
RUN_MODULE(DB_PGSQL_Execute_SQL, false,
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("SQL" , SQL)
);
if( bResult )
{
SetItemText(Item, Name);
}
}
break;
//-----------------------------------------------------
default:
if( DLG_Get_Text(Name, _TL("Rename Table"), _TL("Name")) )
{
CSG_String SQL = "ALTER TABLE \"" + pData->Get_Value() + "\" RENAME TO \"" + CSG_String(&Name) + "\";";
RUN_MODULE(DB_PGSQL_Execute_SQL, false,
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("SQL" , SQL)
);
if( bResult )
{
SetItemText(Item, Name);
}
}
break;
}
}
VALUE
rb_grn_posting_new (grn_posting *posting, grn_id term_id,
VALUE rb_table, VALUE rb_lexicon)
{
VALUE parameters;
parameters = rb_hash_new();
#define SET_PARAMETER(key, value) \
rb_hash_aset(parameters, ID2SYM(rb_intern((key))), INT2NUM((value)))
SET_PARAMETER("record_id", posting->rid);
SET_PARAMETER("section_id", posting->sid);
SET_PARAMETER("term_id", term_id);
SET_PARAMETER("position", posting->pos);
SET_PARAMETER("term_frequency", posting->tf);
SET_PARAMETER("weight", posting->weight);
SET_PARAMETER("n_rest_postings", posting->rest);
#undef SET_PARAMETER
rb_hash_aset(parameters, ID2SYM(rb_intern("table")), rb_table);
rb_hash_aset(parameters, ID2SYM(rb_intern("lexicon")), rb_lexicon);
return rb_funcall(rb_cGrnPosting, rb_intern("new"), 1,
parameters);
}
//---------------------------------------------------------
void CData_Source_PgSQL::Table_Info(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
CSG_Table *pTable = SG_Create_Table();
RUN_MODULE(DB_PGSQL_Table_Info, true, // CTable_Info
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value ())
&& SET_PARAMETER("TABLE" , pTable)
);
if( bResult )
{
g_pData->Show(pTable, 0);
}
else
{
delete(pTable);
}
}
//---------------------------------------------------------
bool CData_Source_PgSQL::Source_Open(CData_Source_PgSQL_Data *pData, bool bDialog)
{
static wxString Username = "******", Password = "******";
if( bDialog )
{
if( !DLG_Login(Username, Password) )
{
return( false );
}
pData->Set_Username(Username);
pData->Set_Password(Password);
}
//-----------------------------------------------------
MSG_General_Add(wxString::Format("%s: %s...", _TL("Connect to Database"), pData->Get_Server().c_str()), true, true);
RUN_MODULE(DB_PGSQL_Get_Connection, false, // CGet_Connection
SET_PARAMETER("PG_HOST", pData->Get_Host ())
&& SET_PARAMETER("PG_PORT", pData->Get_Port ())
&& SET_PARAMETER("PG_NAME", pData->Get_DBName ())
&& SET_PARAMETER("PG_USER", pData->Get_Username())
&& SET_PARAMETER("PG_PWD" , pData->Get_Password())
);
if( bResult )
{
MSG_General_Add(_TL("okay"), false, false, SG_UI_MSG_STYLE_SUCCESS);
return( true );
}
MSG_General_Add(_TL("failed"), false, false, SG_UI_MSG_STYLE_FAILURE);
return( false );
}
//---------------------------------------------------------
bool PGSQL_Connect (const CSG_String &Host, const CSG_String &Port, const CSG_String &DBName)
{
if( PGSQL_is_Connected(Host, Port, DBName) )
{
return( true );
}
wxString Username = "******", Password = "******";
if( !DLG_Login(Username, Password, wxString::Format("%s: %s [%s:%s]", _TL("Connect to Database"), DBName.c_str(), Host.c_str(), Port.c_str())) )
{
return( false );
}
RUN_MODULE(DB_PGSQL_Get_Connection, false, // CGet_Connection
SET_PARAMETER("PG_HOST", Host )
&& SET_PARAMETER("PG_PORT", Port )
&& SET_PARAMETER("PG_NAME", DBName )
&& SET_PARAMETER("PG_USER", Username)
&& SET_PARAMETER("PG_PWD" , Password)
);
return( bResult );
}
//---------------------------------------------------------
bool PGSQL_is_Connected (const CSG_String &Server)
{
CSG_Table Connections;
RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections
for(int i=0; bResult && i<Connections.Get_Count(); i++)
{
if( !Server.Cmp(Connections[i].asString(0)) )
{
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool PGSQL_Get_Connections (CSG_Strings &Servers, double vPostGIS)
{
Servers.Clear();
CSG_Table Connections;
RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections
for(int i=0; bResult && i<Connections.Get_Count(); i++)
{
if( vPostGIS <= 0.0 || vPostGIS <= Connections[i].asDouble("PostGIS") )
{
Servers += Connections[i].asString(0);
}
}
return( Servers.Get_Count() > 0 );
}
//---------------------------------------------------------
void CData_Source_PgSQL::Source_Close(const wxTreeItemId &Item, bool bDelete)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
if( pData->is_Connected() )
{
RUN_MODULE(DB_PGSQL_Del_Connection, true, SET_PARAMETER("CONNECTION", pData->Get_Server()));
}
if( bDelete )
{
Delete(Item);
}
else
{
pData->Set_Username(SG_T(""));
pData->Set_Password(SG_T(""));
}
}
//---------------------------------------------------------
void CData_Source_PgSQL::Table_Drop(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
wxString Name = GetItemText(Item);
switch( pData->Get_Type() )
{
//-----------------------------------------------------
case TYPE_GRID:
if( DLG_Message_Confirm(wxString::Format("%s [%s]", _TL("Do you really want to delete this raster band"), Name.c_str()), _TL("Raster Band Deletion")) )
{
MSG_General_Add(wxString::Format("%s: [%s] %s...", _TL("Deleting raster band"), pData->Get_Server().c_str(), Name.c_str()), true, true);
CSG_String Table = pData->Get_Value().BeforeFirst(':');
CSG_String rid = pData->Get_Value().AfterFirst (':');
CSG_String SQL = "DELETE FROM \"" + Table + "\" WHERE " + rid + ";";
RUN_MODULE(DB_PGSQL_Execute_SQL, false,
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("SQL" , SQL)
);
if( bResult )
{
Delete(Item);
MSG_General_Add(_TL("okay"), false, false, SG_UI_MSG_STYLE_SUCCESS);
}
else
{
MSG_General_Add(_TL("failed"), false, false, SG_UI_MSG_STYLE_FAILURE);
}
}
break;
//-----------------------------------------------------
default:
if( DLG_Message_Confirm(wxString::Format("%s [%s]", _TL("Do you really want to delete the table"), pData->Get_Value().c_str()), _TL("Table Deletion")) )
{
MSG_General_Add(wxString::Format("%s: [%s] %s...", _TL("Deleting table"), pData->Get_Server().c_str(), pData->Get_Value().c_str()), true, true);
RUN_MODULE(DB_PGSQL_Table_Drop, false, // CTable_Drop
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value())
);
if( bResult )
{
Delete(Item);
MSG_General_Add(_TL("okay"), false, false, SG_UI_MSG_STYLE_SUCCESS);
}
else
{
MSG_General_Add(_TL("failed"), false, false, SG_UI_MSG_STYLE_FAILURE);
}
}
break;
}
}
//---------------------------------------------------------
void CData_Source_PgSQL::Table_Open(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
//-----------------------------------------------------
if( pData->Get_Type() == TYPE_TABLE )
{
CSG_Table *pTable = SG_Create_Table();
RUN_MODULE(DB_PGSQL_Table_Load, true, // CTable_Load
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value ())
&& SET_PARAMETER("TABLE" , pTable)
);
if( bResult )
{
g_pData->Show(pTable, 0);
}
else
{
delete(pTable);
}
}
//-----------------------------------------------------
if( pData->Get_Type() == TYPE_SHAPES )
{
CSG_Shapes *pShapes = SG_Create_Shapes();
RUN_MODULE(DB_PGSQL_Shapes_Load, true, // CPGIS_Shapes_Load
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value ())
&& SET_PARAMETER("SHAPES" , pShapes)
);
if( bResult )
{
// g_pData->Show(pShapes, SG_UI_DATAOBJECT_SHOW_NEW_MAP);
}
else
{
delete(pShapes);
}
}
//-----------------------------------------------------
if( pData->Get_Type() == TYPE_GRIDS )
{
RUN_MODULE(DB_PGSQL_Raster_Load, true,
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value ())
);
}
//-----------------------------------------------------
if( pData->Get_Type() == TYPE_GRID )
{
RUN_MODULE(DB_PGSQL_Raster_Load, true,
SET_PARAMETER("CONNECTION", pData->Get_Server())
&& SET_PARAMETER("TABLES" , pData->Get_Value ().BeforeFirst(':'))
&& SET_PARAMETER("WHERE" , pData->Get_Value ().AfterFirst (':'))
);
}
}
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 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 );
}
