void aRTstatictable::Create(SEXP options)
{
string id = GET_STRING_ELEMENT (options, aRTstrId);
int length = GET_INTEGER_ELEMENT (options, "length");
bool genids = GET_BOOL_ELEMENT (options, "generateids");
TeAttributeList attList;
TeAttribute at;
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = length;
at.rep_.name_ = id;
at.rep_.isPrimaryKey_ = true;
attList.push_back(at);
TeTable attTable(TableName, attList, id, id, TeAttrStatic);
PrintSilent("Creating static table \'%s\' on layer \'%s\' ... ", TableName.c_str(), LayerName.c_str());
if( !Layer()->createAttributeTable(attTable) )
{
stringstream err;
err << "Could not create the table:"
<< Database->errorMessage() << endl;
error( StreamToChar(err) );
}
PrintSilentYes;
if(genids) CreateLinkIds(id);
}
bool TeSQLite::getAttributeList(const string& tableName,TeAttributeList& attList)
{
if(!tableExist(tableName))
{
return false;
}
TeDatabasePortal* portal = this->getPortal();
if (!portal)
return false;
string sql = "PRAGMA table_info(" + tableName + ")";
if (!portal->query(sql))
{
delete portal;
return false;
}
while(portal->fetchRow())
{
TeAttribute attr;
attr.rep_.name_ = portal->getData("name");
attr.rep_.isPrimaryKey_ = portal->getBool("pk");
attr.rep_.null_ = !portal->getBool("notnull");
attr.rep_.defaultValue_ = portal->getData("dflt_value");
std::string type = portal->getData("type");
if(type == "TEXT")
{
attr.rep_.type_ = TeSTRING;
}
else if(type == "INTEGER")
{
attr.rep_.type_ = TeINT;
}
else if(type == "REAL")
{
attr.rep_.type_ = TeREAL;
}
else if(type == "BLOB")
{
attr.rep_.type_ = TeBLOB;
}
else
{
attr.rep_.type_ = TeSTRING;
}
attList.push_back(attr);
}
delete portal;
return true;
}
void
createCoverageMetadataTable(TeLayer* layer, std::string& metadataTableName)
{
TeAttributeList attList;
TeAttribute coverageIdAtt;
coverageIdAtt.rep_.type_ = TeSTRING;
coverageIdAtt.rep_.numChar_ = 25;
coverageIdAtt.rep_.name_ = "coverage_id";
coverageIdAtt.rep_.isPrimaryKey_ = true;
attList.push_back(coverageIdAtt);
TeAttribute dimensionIdAtt;
dimensionIdAtt.rep_.type_ = TeINT;
dimensionIdAtt.rep_.name_ = "dimension_id";
dimensionIdAtt.rep_.isPrimaryKey_ = true;
attList.push_back(dimensionIdAtt);
TeAttribute dataTypeAtt;
dataTypeAtt.rep_.type_ = TeINT;
dataTypeAtt.rep_.name_ = "data_type";
dataTypeAtt.rep_.isPrimaryKey_ = false;
attList.push_back(dataTypeAtt);
TeAttribute nameAtt;
nameAtt.rep_.type_ = TeSTRING;
nameAtt.rep_.numChar_ = 25;
nameAtt.rep_.name_ = "name";
nameAtt.rep_.isPrimaryKey_ = false;
attList.push_back(nameAtt);
if (!layer->database()->createTable(metadataTableName, attList))
{
std::string errorMsg = "Couldn't create table '" + metadataTableName + "'.";
throw TeException(UNKNOWN_ERROR_TYPE, errorMsg, false);
}
}
void
createCoverageLayerTable(TeLayer* layer, std::string& tableName)
{
TeAttributeList attList;
TeAttribute geomIdAtt;
geomIdAtt.rep_.type_ = TeINT;
geomIdAtt.rep_.name_ = "geom_id";
geomIdAtt.rep_.isPrimaryKey_ = true;
geomIdAtt.rep_.isAutoNumber_ = true;
attList.push_back(geomIdAtt);
TeAttribute coverageIdAtt;
coverageIdAtt.rep_.type_ = TeSTRING;
coverageIdAtt.rep_.numChar_ = 25;
coverageIdAtt.rep_.name_ = "coverage_id";
coverageIdAtt.rep_.isPrimaryKey_ = false;
attList.push_back(coverageIdAtt);
TeAttribute coverageTableAtt;
coverageTableAtt.rep_.type_ = TeSTRING;
coverageTableAtt.rep_.numChar_ = 255;
coverageTableAtt.rep_.name_ = "coverage_table";
coverageTableAtt.rep_.isPrimaryKey_ = false;
attList.push_back(coverageTableAtt);
TeAttribute lowerXAtt;
lowerXAtt.rep_.type_ = TeREAL;
lowerXAtt.rep_.name_ = "lower_x";
attList.push_back(lowerXAtt);
TeAttribute lowerYAtt;
lowerYAtt.rep_.type_ = TeREAL;
lowerYAtt.rep_.name_ = "lower_y";
attList.push_back(lowerYAtt);
TeAttribute upperXAtt;
upperXAtt.rep_.type_ = TeREAL;
upperXAtt.rep_.name_ = "upper_x";
attList.push_back(upperXAtt);
TeAttribute upperYAtt;
upperYAtt.rep_.type_ = TeREAL;
upperYAtt.rep_.name_ = "upper_y";
attList.push_back(upperYAtt);
if (!layer->database()->createTable(tableName, attList))
{
std::string errorMsg = "Couldn't create table '" + tableName + "'.";
throw TeException(UNKNOWN_ERROR_TYPE, errorMsg, false);
}
}
void aRTexternaltable::Create(SEXP options)
{
string id = GET_STRING_ELEMENT (options, aRTstrId);
int length = GET_INTEGER_ELEMENT (options, "length");
TeAttributeList attList;
TeAttribute at;
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = length;
at.rep_.name_ = id;
at.rep_.isPrimaryKey_ = true;
attList.push_back(at);
//TeAttrTableType atttype; // apaguei aqui 2011/04/22
string link = "";
//atttype = TeAttrExternal;
if( !Database->createTable(TableName, attList))
{
stringstream err;
err << "Could not create the table:"
<< Database->errorMessage() << endl;
delete this;
error( StreamToChar(err) );
}
TeTable attTable(TableName, attList, id, "", TeAttrExternal);
if( !Database->insertTableInfo(-1, attTable))
{
stringstream err;
err << "Could not make the table external:"
<< Database->errorMessage() << endl;
delete this;
error( StreamToChar(err) );
}
/*
TeTable attTable(TableName, attList, id, link, atttype);
if( !Layer()->createAttributeTable(attTable) )
{
stringstream err;
err << "Could not create the table:"
<< Database->errorMessage() << endl;
error( StreamToChar(err) );
}*/
}
void
createCoverageTable(TeLayer* layer, std::string& tableName)
{
TeAttributeList attList;
TeAttribute blockIdAtt;
blockIdAtt.rep_.type_ = TeINT;
blockIdAtt.rep_.name_ = "block_id";
blockIdAtt.rep_.isPrimaryKey_ = true;
attList.push_back(blockIdAtt);
TeAttribute lowerXAtt;
lowerXAtt.rep_.type_ = TeREAL;
lowerXAtt.rep_.name_ = "lower_x";
attList.push_back(lowerXAtt);
TeAttribute lowerYAtt;
lowerYAtt.rep_.type_ = TeREAL;
lowerYAtt.rep_.name_ = "lower_y";
attList.push_back(lowerYAtt);
TeAttribute upperXAtt;
upperXAtt.rep_.type_ = TeREAL;
upperXAtt.rep_.name_ = "upper_x";
attList.push_back(upperXAtt);
TeAttribute upperYAtt;
upperYAtt.rep_.type_ = TeREAL;
upperYAtt.rep_.name_ = "upper_y";
attList.push_back(upperYAtt);
TeAttribute numElementsAtt;
numElementsAtt.rep_.type_ = TeINT;
numElementsAtt.rep_.name_ = "num_elements";
attList.push_back(numElementsAtt);
TeAttribute spatialDataAtt;
spatialDataAtt.rep_.type_ = TeBLOB;
spatialDataAtt.rep_.name_ = "spatial_data";
attList.push_back(spatialDataAtt);
if (!layer->database()->createTable(tableName, attList))
{
std::string errorMsg = "Couldn't create table '" + tableName + "'.";
throw TeException(UNKNOWN_ERROR_TYPE, errorMsg, false);
}
}
bool updateDB20To30(TeDatabase* db, string& errorMessage)
{
TeAttribute fattr;
// ----- te_grouping
if(db->columnExist("te_grouping", "grouping_function", fattr) == false)
{
TeAttributeRep atRep;
atRep.type_ = TeSTRING;
atRep.name_ = "grouping_function";
atRep.numChar_ = 10;
if(db->addColumn("te_grouping", atRep) == false)
{
errorMessage = "The column grouping_function could not be appended!\n";
errorMessage += db->errorMessage();
return false;
}
string upd;
if(db->columnExist("te_theme_application", "group_function", fattr))
{
upd = " UPDATE te_grouping g, te_theme_application ta ";
upd += " SET g.grouping_function = ta.group_function ";
upd += " WHERE ta.theme_id = g.theme_id ";
if(!db->execute (upd))
{
errorMessage = db->errorMessage();
return false;
}
db->deleteColumn("te_theme_application", "group_function");
}
else
{
upd = " UPDATE te_grouping g ";
upd += " SET g.grouping_function = 'AVG' ";
if(!db->execute (upd))
{
errorMessage = db->errorMessage();
return false;
}
}
}
// ----- te_theme_application
if(db->columnExist("te_theme_application", "chart_function", fattr) == false)
{
TeAttributeRep atRep;
atRep.type_ = TeSTRING;
atRep.name_ = "chart_function";
atRep.numChar_ = 10;
if(db->addColumn("te_theme_application", atRep) == false)
{
errorMessage = "The column chart_function could not be appended!\n";
errorMessage += db->errorMessage();
return false;
}
db->execute("UPDATE te_theme_application SET chart_function = 'AVG'");
}
// ----- te_theme
if(db->columnExist("te_theme", "visible_rep", fattr) == false)
{
TeAttributeRep atRep;
atRep.type_ = TeINT;
atRep.name_ = "visible_rep";
if(db->addColumn("te_theme", atRep) == false)
{
errorMessage = "The column visible_rep could not be appended!\n";
errorMessage += db->errorMessage();
return false;
}
atRep.name_ = "enable_visibility";
if(db->addColumn("te_theme", atRep) == false)
{
errorMessage = "The column enable_visibility could not be appended!\n";
errorMessage += db->errorMessage();
return false;
}
string upd = " UPDATE te_theme t, te_theme_application ta ";
upd += " SET t.visible_rep = ta.visible_rep ";
upd += " WHERE ta.theme_id = t.theme_id ";
if(!db->execute (upd))
{
errorMessage = db->errorMessage();
return false;
}
upd = " UPDATE te_theme t, te_theme_application ta ";
upd += " SET t.enable_visibility = ta.enable_visibility ";
upd += " WHERE ta.theme_id = t.theme_id ";
if(!db->execute (upd))
{
errorMessage = db->errorMessage();
return false;
}
db->deleteColumn("te_theme_application", "visible_rep");
db->deleteColumn("te_theme_application", "enable_visibility");
}
//if for ADO passar todas as tabelas para aceitar comprimento iguel a zero!!!
if(db->dbmsName() == "Ado")
{
//te_layer
//te_layer_table
db->allowEmptyString ("te_layer_table", "attr_initial_time");
db->allowEmptyString ("te_layer_table", "attr_final_time");
db->allowEmptyString ("te_layer_table", "user_name");
//te_representation
db->allowEmptyString ("te_representation", "description");
//te_view
db->allowEmptyString ("te_view", "user_name");
//te_visual
db->allowEmptyString ("te_visual", "lib_name");
db->allowEmptyString ("te_visual", "contour_lib_name");
db->allowEmptyString ("te_visual", "family");
//te_legend
db->allowEmptyString ("te_legend", "lower_value");
db->allowEmptyString ("te_legend", "upper_value");
db->allowEmptyString ("te_legend", "label");
//te_theme
db->allowEmptyString ("te_theme", "generate_attribute_where");
db->allowEmptyString ("te_theme", "generate_spatial_where");
db->allowEmptyString ("te_theme", "generate_temporal_where");
db->allowEmptyString ("te_theme", "collection_table");
//te_grouping
db->allowEmptyString ("te_grouping", "grouping_attr");
db->allowEmptyString ("te_grouping", "grouping_norm_attr");
db->allowEmptyString ("te_grouping", "grouping_function");
//te_theme_application
db->allowEmptyString ("te_theme_application", "refine_attribute_where");
db->allowEmptyString ("te_theme_application", "refine_spatial_where");
db->allowEmptyString ("te_theme_application", "refine_temporal_where");
db->allowEmptyString ("te_theme_application", "grouping_color");
db->allowEmptyString ("te_theme_application", "pie_dimension_attr");
db->allowEmptyString ("te_theme_application", "text_table");
db->allowEmptyString ("te_theme_application", "chart_function");
}
//------------ auxiliary collection
TeDatabasePortal* portal = db->getPortal();
if(!portal)
return false;
string sql = " SELECT theme_id, visible_rep FROM te_theme ";
if(!portal->query(sql))
{
delete portal;
return true;
}
while(portal->fetchRow ())
{
string themeId = portal->getData(0);
int visRep = atoi(portal->getData(1));
string collExtTable = "te_collection_"+ themeId +"_aux";
if ((db->tableExist("te_collection_"+ themeId)) &&
((visRep & TeRASTER) != TeRASTER) &&
(!db->tableExist(collExtTable)))
{
TeTheme* theme = new TeTheme();
theme->id(atoi(themeId.c_str()));
if(!db->loadTheme (theme))
{
delete portal;
return false;
}
string up = "UPDATE " + theme->collectionTable() + " SET c_object_status = 0";
up += " WHERE c_object_status <> " + Te2String(theme->pointingLegend().id());
up += " AND c_object_status <> " + Te2String(theme->queryLegend().id());
up += " AND c_object_status <> " + Te2String(theme->queryAndPointingLegend().id());
db->execute(up);
up = "UPDATE " + theme->collectionTable() + " SET c_object_status = 1";
up += " WHERE c_object_status = " + Te2String(theme->pointingLegend().id());
db->execute(up);
up = "UPDATE " + theme->collectionTable() + " SET c_object_status = 2";
up += " WHERE c_object_status = " + Te2String(theme->queryLegend().id());
db->execute(up);
up = "UPDATE " + theme->collectionTable() + " SET c_object_status = 3";
up += " WHERE c_object_status = " + Te2String(theme->queryAndPointingLegend().id());
db->execute(up);
if ((!theme->createCollectionAuxTable()) || (!theme->populateCollectionAux()))
{
errorMessage = "Fail to mount the auxiliary table of the collection!\n";
errorMessage += db->errorMessage();
delete portal;
return false;
}
theme->collectionAuxTable(collExtTable);
theme->addThemeTable(collExtTable);
string oldTCE = theme->collectionTable() + "_ext";
if (db->tableExist(oldTCE))
{
string delTable = "DROP TABLE " + oldTCE;
db->execute(delTable);
}
}
}
//------------ end auxiliary collection
portal->freeResult();
//------------ text table
// if text table have not text visual table associated, create it
string sel = "SELECT geom_table FROM te_representation WHERE";
sel += " geom_type = " + Te2String(TeTEXT);
if(portal->query(sel))
{
while(portal->fetchRow())
{
string table = portal->getData(0);
string tvis = table + "_txvisual";
if(!db->tableExist(tvis))
{
TeAttributeList atl;
TeAttribute at;
at.rep_.name_ = "geom_id";
at.rep_.type_ = TeINT;
at.rep_.numChar_ = 0;
at.rep_.isPrimaryKey_ = true;
atl.push_back(at);
at.rep_.isPrimaryKey_ = false;
at.rep_.name_ = "dot_height";
at.rep_.type_ = TeINT;
atl.push_back(at);
at.rep_.name_ = "fix_size";
at.rep_.type_ = TeINT;
atl.push_back(at);
at.rep_.name_ = "color";
at.rep_.type_ = TeINT;
atl.push_back(at);
at.rep_.name_ = "family";
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = 128;
atl.push_back(at);
at.rep_.name_ = "bold";
at.rep_.type_ = TeINT;
at.rep_.numChar_ = 0;
atl.push_back(at);
at.rep_.name_ = "italic";
at.rep_.type_ = TeINT;
atl.push_back(at);
db->createTable(tvis, atl);
string fk = "fk_" + tvis;
db->createRelation(fk, tvis, "geom_id", table, "geom_id", true);
string ins = "INSERT INTO " + tvis + " (geom_id) SELECT geom_id FROM " + table;
db->execute(ins);
string popule = "UPDATE " + tvis;
popule += " SET dot_height = 12";
popule += ", fix_size = 0";
popule += ", color = 16711680";
popule += ", family = 'verdana'";
popule += ", bold = 1";
popule += ", italic = 0";
if(!db->execute(popule))
{
errorMessage = "Fail to generate the text visual table!\n";
errorMessage += db->errorMessage();
delete portal;
return false;;
}
}
}
}
//------------ end text table
delete portal;
return true;
}
bool updateDB310To311(TeDatabase* db, string& errorMessage)
{
string sql = " SELECT collection_table FROM te_theme ";
TeDatabasePortal* portal = db->getPortal();
if(!portal)
return false;
if(!portal->query(sql))
{
delete portal;
return false;
}
while(portal->fetchRow())
{
string tableName = portal->getData(0);
if(!db->tableExist(tableName+"_aux"))
continue;
TeDatabasePortal* portal2 = db->getPortal();
if(!portal2)
{
delete portal;
return false;
}
sql = " SELECT * FROM "+ tableName+"_aux WHERE 1=2";
if(!portal2->query(sql))
{
delete portal;
delete portal2;
return false;
}
TeAttributeList attrList;
for(int i=0; i<portal2->numFields(); ++i)
{
TeAttribute attr = portal2->getAttribute(i);
attr.rep_.isPrimaryKey_= false;
if(TeConvertToUpperCase(portal2->getAttribute(i).rep_.name_) != "UNIQUE_ID" )
attrList.push_back(attr);
}
delete portal2;
//add new autonumber column
TeAttribute attr;
attr.rep_.name_= "unique_id" ;
attr.rep_.type_= TeINT;
attr.rep_.isAutoNumber_ = true;
attr.rep_.isPrimaryKey_ = true;
attrList.push_back(attr);
//create new table
if(!db->createTable(tableName+"_aux2", attrList))
{
errorMessage = "Error creating table "+ tableName+"_aux2 !\n";
errorMessage += db->errorMessage();
delete portal;
return false;
}
//insert records
string ins = " INSERT INTO "+ tableName +"_aux2 ( ";
string ins2 ="";
for(unsigned int j=0; j<(attrList.size()-1); ++j)
{
if(j>0)
ins2 += ",";
ins2 += attrList[j].rep_.name_;
}
ins += ins2 +" ) SELECT "+ ins2;
ins += " FROM "+ tableName+"_aux";
if(!db->execute(ins))
{
errorMessage = "Error inserting table "+ tableName+"_aux2 !\n";
errorMessage += db->errorMessage();
delete portal;
return false;
}
sql = " DROP TABLE "+ tableName+"_aux";
if(db->tableExist(tableName+"_aux"))
{
if(!db->execute(sql))
{
errorMessage = "Error dropping table "+ tableName+"_aux2 !\n";
errorMessage += db->errorMessage();
delete portal;
return false;
}
}
if(!db->alterTable(tableName+"_aux2", tableName+"_aux"))
{
errorMessage = "Error renaming table "+ tableName+"_aux2 !\n";
errorMessage += db->errorMessage();
delete portal;
return false;
}
}
delete portal;
return true;
}
bool TeExportPolygonSet2SHP( const TePolygonSet& ps,const std::string& base_file_name )
{
// creating files names
std::string dbfFilename = base_file_name + ".dbf";
std::string shpFilename = base_file_name + ".shp";
// creating polygons attribute list ( max attribute size == 25 )
TeAttributeList attList;
TeAttribute at;
at.rep_.type_ = TeSTRING; //the id of the cell
at.rep_.numChar_ = 25;
at.rep_.name_ = "object_id_";
at.rep_.isPrimaryKey_ = true;
attList.push_back(at);
/* DBF output file handle creation */
DBFHandle hDBF = TeCreateDBFFile (dbfFilename, attList);
if ( hDBF == 0 )
return false;
/* SHP output file handle creation */
SHPHandle hSHP = SHPCreate( shpFilename.c_str(), SHPT_POLYGON );
if( hSHP == 0 )
{
DBFClose( hDBF );
return false;
}
/* Writing polygons */
int iRecord = 0;
int totpoints = 0;
double *padfX, *padfY;
SHPObject *psObject;
int posXY, npoints, nelem;
int nVertices;
int* panParts;
TePolygonSet::iterator itps;
TePolygon poly;
for (itps = ps.begin() ; itps != ps.end() ; itps++ ) {
poly=(*itps);
totpoints = 0;
nVertices = poly.size();
for (unsigned int n=0; n<poly.size();n++) {
totpoints += poly[n].size();
}
panParts = (int *) malloc(sizeof(int) * nVertices);
padfX = (double *) malloc(sizeof(double) * totpoints);
padfY = (double *) malloc(sizeof(double) * totpoints);
posXY = 0;
nelem = 0;
for (unsigned int l=0; l<poly.size(); ++l) {
if (l==0) {
if (TeOrientation(poly[l]) == TeCOUNTERCLOCKWISE) {
TeReverseLine(poly[l]);
}
} else {
if (TeOrientation(poly[l]) == TeCLOCKWISE) {
TeReverseLine(poly[l]);
}
}
npoints = poly[l].size();
panParts[nelem]=posXY;
for (int m=0; m<npoints; m++ ) {
padfX[posXY] = poly[l][m].x_;
padfY[posXY] = poly[l][m].y_;
posXY++;
}
nelem++;
}
psObject = SHPCreateObject( SHPT_POLYGON, -1, nelem, panParts, NULL,
posXY, padfX, padfY, NULL, NULL );
int shpRes = SHPWriteObject( hSHP, -1, psObject );
if (shpRes == -1 )
{
DBFClose( hDBF );
SHPClose( hSHP );
return false;
}
SHPDestroyObject( psObject );
free( panParts );
free( padfX );
free( padfY );
// writing attributes - same creation order
DBFWriteStringAttribute(hDBF, iRecord, 0, poly.objectId().c_str() );
iRecord++;
}
DBFClose( hDBF );
SHPClose( hSHP );
return true;
}
bool
TeExportQuerierToShapefile(TeQuerier* querier, const std::string& base)
{
// check initial conditions
if (!querier)
return false;
if (!querier->loadInstances())
return false;
// Get the list of attributes defined by the input querier
bool onlyObjId = false;
TeAttributeList qAttList = querier->getAttrList();
if (qAttList.empty())
{
TeAttributeList qAttList;
TeAttribute at;
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = 100;
at.rep_.name_ = "ID";
at.rep_.isPrimaryKey_ = true;
qAttList.push_back(at);
onlyObjId = true;
}
// Handles to each type of geometries that will be created if necessary
DBFHandle hDBFPol = 0;
SHPHandle hSHPPol = 0;
DBFHandle hDBFLin = 0;
SHPHandle hSHPLin = 0;
DBFHandle hDBFPt = 0;
SHPHandle hSHPPt = 0;
// Some auxiliary variables
int totpoints;
double* padfX;
double* padfY;
unsigned int nVertices;
int* panPart;
SHPObject *psObject;
unsigned int posXY, npoints, nelem;
int shpRes;
// progress information
if (TeProgress::instance())
TeProgress::instance()->setTotalSteps(querier->numElemInstances());
clock_t t0, t1, t2;
t2 = clock();
t0 = t1 = t2;
int dt = CLOCKS_PER_SEC/2;
int dt2 = CLOCKS_PER_SEC; //* .000001;
// Loop through the instances writting their geometries and attributes
unsigned int iRecPol=0, iRecLin=0, iRecPt=0;
unsigned int n, l, m;
unsigned int nIProcessed = 0;
TeSTInstance st;
while(querier->fetchInstance(st))
{
totpoints = 0;
nVertices = 0;
if (st.hasPolygons())
{
TePolygonSet& polSet = st.getPolygons();
TePolygonSet::iterator itps;
int nVerticesCount = 0;
for (itps = polSet.begin(); itps != polSet.end(); ++itps)
{
nVertices = (*itps).size();
nVerticesCount += nVertices;
for (n=0; n<nVertices;++n)
totpoints += (*itps)[n].size();
}
panPart = (int *) malloc(sizeof(int) * nVerticesCount);
padfX = (double *) malloc(sizeof(double) * totpoints);
padfY = (double *) malloc(sizeof(double) * totpoints);
posXY = 0;
nelem = 0;
for (itps = polSet.begin(); itps != polSet.end(); ++itps)
{
TePolygon poly = *itps;
for (l=0; l<poly.size(); ++l)
{
if (l==0)
{
if (TeOrientation(poly[l]) == TeCOUNTERCLOCKWISE)
TeReverseLine(poly[l]);
}
else
{
if (TeOrientation(poly[l]) == TeCLOCKWISE)
TeReverseLine(poly[l]);
}
npoints = poly[l].size();
panPart[nelem]=posXY;
for (m=0; m<npoints; ++m)
{
padfX[posXY] = poly[l][m].x_;
padfY[posXY] = poly[l][m].y_;
posXY++;
}
nelem++;
}
}
psObject = SHPCreateObject(SHPT_POLYGON, -1, nelem, panPart, NULL, posXY, padfX, padfY, NULL, NULL);
if (hSHPPol == 0)
{
string fname = base + "_pol.shp";
hSHPPol = SHPCreate(fname.c_str(), SHPT_POLYGON);
assert (hSHPPol != 0);
}
shpRes = SHPWriteObject(hSHPPol, -1, psObject);
SHPDestroyObject(psObject);
free(panPart);
free(padfX);
free(padfY);
assert(shpRes != -1);
if (hDBFPol == 0)
{
hDBFPol = TeCreateDBFFile(base + "_pol.dbf", qAttList);
assert (hDBFPol != 0);
}
if (onlyObjId)
{
DBFWriteStringAttribute(hDBFPol, iRecPol, 0, st.objectId().c_str());
}
else
{
string val;
for (n=0; n<qAttList.size();++n)
{
st.getPropertyValue(val,n);
if (qAttList[n].rep_.type_ == TeSTRING || qAttList[n].rep_.type_ == TeDATETIME)
{
DBFWriteStringAttribute(hDBFPol, iRecPol, n, val.c_str());
}
else if (qAttList[n].rep_.type_ == TeINT)
{
DBFWriteIntegerAttribute(hDBFPol, iRecPol, n, atoi(val.c_str()));
}
else if (qAttList[n].rep_.type_ == TeREAL)
{
DBFWriteDoubleAttribute(hDBFPol, iRecPol, n, atof(val.c_str()));
}
}
}
++iRecPol;
}
if (st.hasCells())
{
TeCellSet& cellSet = st.getCells();
nVertices = cellSet.size();
totpoints = nVertices*5;
panPart = (int *) malloc(sizeof(int) * nVertices);
padfX = (double *) malloc(sizeof(double) * totpoints);
padfY = (double *) malloc(sizeof(double) * totpoints);
posXY = 0;
nelem = 0;
TeCellSet::iterator itcs;
for (itcs=cellSet.begin(); itcs!=cellSet.end(); ++itcs)
{
panPart[nelem]=posXY;
padfX[posXY] = (*itcs).box().lowerLeft().x();
padfY[posXY] = (*itcs).box().lowerLeft().y();
posXY++;
padfX[posXY] = (*itcs).box().upperRight().x();
padfY[posXY] = (*itcs).box().lowerLeft().y();
posXY++;
padfX[posXY] = (*itcs).box().upperRight().x();
padfY[posXY] = (*itcs).box().upperRight().y();
posXY++;
padfX[posXY] = (*itcs).box().lowerLeft().x();
padfY[posXY] = (*itcs).box().upperRight().y();
posXY++;
padfX[posXY] = (*itcs).box().lowerLeft().x();
padfY[posXY] = (*itcs).box().lowerLeft().y();
++posXY;
++nelem;
}
psObject = SHPCreateObject(SHPT_POLYGON, -1, nelem, panPart, NULL,posXY, padfX, padfY, NULL, NULL);
if (hSHPPol == 0)
{
string fname = base + "_pol.shp";
hSHPPol = SHPCreate(fname.c_str(), SHPT_POLYGON);
assert (hSHPPol != 0);
}
shpRes = SHPWriteObject(hSHPPol, -1, psObject);
SHPDestroyObject(psObject);
free(panPart);
free(padfX);
free(padfY);
assert(shpRes != -1);
if (hDBFPol == 0)
{
hDBFPol = TeCreateDBFFile(base + "_pol.dbf", qAttList);
assert (hDBFPol != 0);
}
if (onlyObjId)
{
DBFWriteStringAttribute(hDBFPol, iRecPol, 0, st.objectId().c_str());
}
else
{
string val;
for (n=0; n<qAttList.size();++n)
{
st.getPropertyValue(val,n);
if (qAttList[n].rep_.type_ == TeSTRING || qAttList[n].rep_.type_ == TeDATETIME)
{
DBFWriteStringAttribute(hDBFPol, iRecPol, n, val.c_str());
}
else if (qAttList[n].rep_.type_ == TeINT)
{
DBFWriteIntegerAttribute(hDBFPol, iRecPol, n, atoi(val.c_str()));
}
else if (qAttList[n].rep_.type_ == TeREAL)
{
DBFWriteDoubleAttribute(hDBFPol, iRecPol, n, atof(val.c_str()));
}
}
}
++iRecPol;
}
if (st.hasLines())
{
TeLineSet& lineSet = st.getLines();
nVertices = lineSet.size();
TeLineSet::iterator itls;
for (itls=lineSet.begin(); itls!=lineSet.end(); ++itls)
totpoints += (*itls).size();
panPart = (int *) malloc(sizeof(int) * nVertices);
padfX = (double *) malloc(sizeof(double) * totpoints);
padfY = (double *) malloc(sizeof(double) * totpoints);
posXY = 0;
nelem = 0;
for (itls=lineSet.begin(); itls!=lineSet.end(); ++itls)
{
panPart[nelem]=posXY;
for (l=0; l<(*itls).size(); ++l)
{
padfX[posXY] = (*itls)[l].x();
padfY[posXY] = (*itls)[l].y();
++posXY;
}
++nelem;
}
psObject = SHPCreateObject(SHPT_ARC, -1, nVertices, panPart, NULL, posXY, padfX, padfY, NULL, NULL);
if (hSHPLin == 0)
{
string fname = base + "_lin.shp";
hSHPLin = SHPCreate(fname.c_str(), SHPT_ARC);
assert (hSHPLin != 0);
}
shpRes = SHPWriteObject(hSHPLin, -1, psObject);
SHPDestroyObject(psObject);
free(panPart);
free(padfX);
free(padfY);
assert(shpRes != -1);
if (hDBFLin == 0)
{
hDBFLin = TeCreateDBFFile(base + "_lin.dbf", qAttList);
assert (hDBFLin != 0);
}
if (onlyObjId)
{
DBFWriteStringAttribute(hDBFLin, iRecLin, 0, st.objectId().c_str());
}
else
{
string val;
for (n=0; n<qAttList.size();++n)
{
st.getPropertyValue(val,n);
if (qAttList[n].rep_.type_ == TeSTRING || qAttList[n].rep_.type_ == TeDATETIME)
{
DBFWriteStringAttribute(hDBFLin, iRecLin, n, val.c_str());
}
else if (qAttList[n].rep_.type_ == TeINT)
{
DBFWriteIntegerAttribute(hDBFLin, iRecLin, n, atoi(val.c_str()));
}
else if (qAttList[n].rep_.type_ == TeREAL)
{
DBFWriteDoubleAttribute(hDBFLin, iRecLin, n, atof(val.c_str()));
}
}
}
++iRecLin;
}
if (st.hasPoints())
{
TePointSet& pointSet = st.getPoints();
nVertices = pointSet.size();
panPart = (int *) malloc(sizeof(int) * nVertices);
padfX = (double *) malloc(sizeof(double) * nVertices);
padfY = (double *) malloc(sizeof(double) * nVertices);
nelem = 0;
TePointSet::iterator itpts;
for (itpts=pointSet.begin(); itpts!=pointSet.end(); ++itpts)
{
panPart[nelem] = nelem;
padfX[nelem] = (*itpts).location().x();
padfY[nelem] = (*itpts).location().y();
++nelem;
}
psObject = SHPCreateObject(SHPT_POINT, -1, nVertices, panPart, NULL, nVertices, padfX, padfY, NULL, NULL );
if (hSHPPt == 0)
{
string fname = base + "_pt.shp";
hSHPPt = SHPCreate(fname.c_str(), SHPT_POINT);
assert (hSHPPt != 0);
}
shpRes = SHPWriteObject(hSHPPt, -1, psObject);
SHPDestroyObject(psObject);
free(panPart);
free(padfX);
free(padfY);
assert(shpRes != -1);
if (hDBFPt == 0)
{
hDBFPt = TeCreateDBFFile(base + "_pt.dbf", qAttList);
assert (hDBFPt != 0);
}
if (onlyObjId)
{
DBFWriteStringAttribute(hDBFPt, iRecPt, 0, st.objectId().c_str());
}
else
{
string val;
for (n=0; n<qAttList.size();++n)
{
st.getPropertyValue(val,n);
if (qAttList[n].rep_.type_ == TeSTRING || qAttList[n].rep_.type_ == TeDATETIME)
{
DBFWriteStringAttribute(hDBFPt, iRecPt, n, val.c_str());
}
else if (qAttList[n].rep_.type_ == TeINT)
{
DBFWriteIntegerAttribute(hDBFPt, iRecPt, n, atoi(val.c_str()));
}
else if (qAttList[n].rep_.type_ == TeREAL)
{
DBFWriteDoubleAttribute(hDBFPt, iRecPt, n, atof(val.c_str()));
}
}
}
++iRecPt;
}
++nIProcessed;
if (TeProgress::instance() && int(t2-t1) > dt)
{
t1 = t2;
if(((int)(t2-t0) > dt2))
{
if (TeProgress::instance()->wasCancelled())
break;
else
TeProgress::instance()->setProgress(nIProcessed);
}
}
}
if (hDBFPol != 0)
DBFClose(hDBFPol);
if (hSHPPol != 0)
SHPClose(hSHPPol);
if (hDBFLin != 0)
DBFClose(hDBFLin);
if (hSHPLin != 0)
SHPClose(hSHPLin);
if (hDBFPt != 0)
DBFClose(hDBFPt);
if (hSHPPt != 0)
SHPClose(hSHPPt);
if (TeProgress::instance())
TeProgress::instance()->reset();
return true;
}