Figure 1.1 – TerraLib architecture.

Layered architecture

TerraView Example

• Database: represents a repository of information that contains the geographical data as well as its organization model. A TerraLib database can be materialized in different DBMS's, commercial or open source, as long as they are either able to store binary long fields or provide spatial extensions accessible by software.
• Layer: is a structure that aggregates a set of spatial information that are located over a geographical region and that shares a set of attributes. Examples of layers are thematic maps (soil or vegetation maps), cadastral maps of geographical objects (map of districts of a city) or raster data such as satellite imagery. A layer knows the geographical projection of its spatial component.
  Layers are inserted in the database by routines that import geographical data files in interchange formats such as shapefiles, MID-MIF or GeoTiff. Layers also can be generated by processing other layers already stored in database.
• Representation:deals with the representation model for the spatial component ^[1] of the data in of a layer. It can be vector or raster type. For the vector type TerraLib deals with points, lines or areas geometries. It also support other representations that are more complex, such as cell spaces and networks.For the raster type, TerraLib support multi-dimensional regular grids.
  TerraLib allows that a geographical object of a layer to be associated to different vector representations (e.g. a city can be represented by the polygon that describes its political boundaries or by a point that represents its center). The entity representation in TerraLib stores the information about the minimum boundary rectangle or the vertical and horizontal resolutions of a representations of raster type.
• Cartographical Projection: represents the geographical reference of the spatial component of the geographical data. The geographical projections allow the mapping of the Earth surface to a Cartesian plane(Snyder, 1987).
• Theme: is used to define a selection over the data of a layer. This selection can be based on some criteria that has to be valid for the spatial or descriptive component of the data. A theme also defines the visual presentation, or the graphical presentation, of the spatial component of the objects selected by the theme. A Theme can also define a way to group objects, creating legends that characterize the groups.
• View: define a particular user view of the database. It defines which themes should be visualizes or processed conjointly. Besides that, as each layer can be derived from a theme with a different geographical projection, the view defines the common projection to be used to visualize or process the themes that it aggregates.
• Visual: represents a set of presentation attributes for the geometrical representation of the data. For instance, filling and contour colors for polygons, thickness and colors for lines or symbols for points. Transparency and line styles, etc.
• Legend: a legend characterizes a group of data, in a theme, that should be presented with the same Visual, when they are grouped in some way.

Figure 3.1 – Some concrete DBMS drivers provided by TerraLib.

int main()
{
	TeDatabase* db;
	int op;
	cout << "Select a DBMS: 1) ACCESS 2) MySQL \n";
	cin >> op;
	if (op == 1)
		db = new TeAdo();     // Uses ACCESS through ADO
	else
		db = new TeMySQL();   // Uses MySQL
// ... uses only db
	return 0;
}

• Metadata Tables: used to store TerraLib concepts. They have a pre-defined format reflecting the TerraLib classes. The set of metadata tables is called TerraLib Conceptual Data Model
• Data Tables: used to store geographic data itself - spatial and alphanumeric components. The tables that store the alphanumeric attributes do not have a pre-defined format. See below an example of a table containing the attributes of the Districts of a city:

#include <TeMySQL.h>
int main()
{
	// DBMS server parameters
	string host = "localhost";
	string dbname = "TerraTeste";
	string user = "root";
	string password = "";

	// Create a new database
	TeDatabase* db = new TeMySQL();
	if (!db->newDatabase(dbname,user, password, host))
	{
		cout << "Error: " << db->errorMessage() << endl;
		return 1;
	}

	cout << "The database \"" << dbname;
	cout <<"\" was successfully created in the \""  << host <<  "\"";
	cout << " to the user \"" << user << "\"!"  << endl;
	// Close the database
	db->close();
	delete db;
	return 0;
}

Figure 3.2 – Main tables of the conceptual model.

• Creation of a database;
• Importing of a geographical data from a file;
• Creation of a view;
• Creation of a theme using the layer and inserting it in the view.

#include<TeMySQL.h>
int main()
{
	// Open a connection to the database server
	TeDatabase* db = new TeMySQL();
	// Server parameters
	string host ="localhost";
	string bname = "TerraTeste";
	string user = "root";
	string password = "";
	if (!db->connect(host,user, password,dbname,0))
	{
		cout<< "Error: " << db->errorMessage() << endl;
		return 0;
	}
	cout << “Connection to the database: “ << dbname  << “ is opened.“;
	db->close();
	delete db;
}

// Connects to a database 
// Import some file
string filename = ""../data/Distritos.mif"; 
TeLayer* newLayer = TeImportMIF(filename,db_);                         
if (newLayer) 
	cout << "File MID/MIF was imported to the database\n";
else
{
	cout <<"Error importing the data\n";
	db_->close();
}

Observe that a record was created on the te_layer table and also two new tables were also created: one to store the polygons that represent the data spatial component and another for store its attributes.

Back to top.

TeDatum dSAD69 = TeDatumFactory::make("SAD69");		// SAD69 Spheroid
TeDatum dWGS84 = TeDatumFactory::make("WGS84");			// WGS84 Spheroid

// UTM: Origin Latitude -45.0
// TeCDR: "Converting from Decimal Degrees to Radians"
TeUtm* pUTM = new TeUtm(dSAD69,-45.0*TeCDR);
// Polyconic:  Origin Latitude -45.0
TePolyconic* pPolyconic = new TePolyconic(dWGS84,-45.0*TeCDR);
// Original coordinate in  UTM

TeCoord2D pt1(340033.47,7391306.21);
// Converting from UTM to polyconic
pUTM->setDestinationProjection(pPolyconic);
// Converting to Lat Long
TeCoord2D ll = pUTM->PC2LL(pt1);
// Converting to the output projection
TeCoord2D pt2 = pPolyconic->LL2PC(ll);
printf("UTM ->Polyconic \n");
printf("(%.4f, %.4f)-> ",pt1.x(), pt1.y());
printf("(%.4f, %.4f)\n",pt2.x(), pt2.y());

// Converting from Polyconic to UTM
pPolyconic->setDestinationProjection(pUTM);
ll = pPolyconic->PC2LL(pt2);
pt1 = pUTM->LL2PC(ll);
printf("\nPolyconic-> UTM \n");
printf("(%.4f,%.4f) -> ",pt2.x(), pt2.y());
printf("(%.4f, %.4f)\n",pt1.x(), pt1.y());

TeLayer* layer = new TeLayer(layerName, db);
string filename = "../data/EstadosBrasil.shp";	
string tablename = "BrasilIBGE";	
string linkcolumn = "SPRROTULO";	

if (TeImportShape(layer, filename, tablename, linkcolumn))
	cout >> "The shapefile was imported successfully into the 
              TerraLib database!\n" << endl;
else
	cout >> "Error importing the shapefile!\n" << endl;

TeDatum sad69 = TeDatumFactory::make("SAD69");
TePolyconic* proj = new TePolyconic(sad69, -54.0*TeCDR);
layer->setProjection(proj);  //Set the correct projection

• Points: represented by the class TePoint, implemented as a single instance of a TeCoord2D;
• Lines: composed by one or more segments are represented by the class TeLine2D, implemented as a vector of two or more TeCoord2D;
• Rings: represented by the class TeLinearRing, are closed lines where the last coordinate is equal to the first one. The class TeLinearRing is implemented as a single instance of a TeLine2D that satisfies the closeness restriction;
• Polygons: represented by the class TePolygon, are delimitation of areas that can have zero or more holes. Are implemented as a vector of TeLinearRing. The first ring of the vector is always the external ring while the other rings, if they exist, are the holes or child of the external ring.

Figure 6.1 – Main geometry classes of TerraLib (adapted of Queiroz, 2003)

// Creates a set of lines
 TeLine2D reta;
 reta.add(TeCoord2D(500,500));
 reta.add(TeCoord2D(600,500));
 reta.add(TeCoord2D(700,500));
 reta.objectId("reta");

 TeLine2D ele;
 ele.add(TeCoord2D(700,700));
 ele.add(TeCoord2D(800,600));
 ele.add(TeCoord2D(900,600));
 ele.objectId("ele");

 TeLineSet ls;
 ls.add(reta);
 ls.add(ele);

 // Create a set of polygons
 // A simple polygon
 
 TeLine2D line;
 line.add(TeCoord2D(900,900));
 line.add(TeCoord2D(900,1000));
 line.add(TeCoord2D(1000,1000));
 line.add(TeCoord2D(1000,900));
 line.add(TeCoord2D(900,900));

 TeLinearRing r1(line);
 TePolygon poly1;
 poly1.add(r1);
 poly1.objectId("spoli");

 // A polygon with a hole
 TeLine2D line2;
 line2.add(TeCoord2D(200,200));
 line2.add(TeCoord2D(200,400));
 line2.add(TeCoord2D(400,400));
 line2.add(TeCoord2D(400,200));
 line2.add(TeCoord2D(200,200));
 TeLinearRing r2(line2);

 TeLine2D line3;
 line3.add(TeCoord2D(250,250));
 line3.add(TeCoord2D(250,300));
 line3.add(TeCoord2D(300,300));
 line3.add(TeCoord2D(300,250));
 line3.add(TeCoord2D(250,250));
 TeLinearRing r3(line3);
 TePolygon poly2;
 poly2.add(r2);
 poly2.add(r3);
 poly2.objectId("cpoli");
 TePolygonSet ps;
 ps.add(poly1);
 ps.add(poly2);

 // Creates a set of points.
 TePoint p1(40,40);
 p1.objectId("ponto1");
 TePointSet pos;
 pos.add(p1);
 

// Retrieves the layer of states
TeLayer* estados = new TeLayer("Brasil");
db->loadLayer(estados); 
// Creates a cell space over the layer extension
// where each cell has a resolution of a  1/100 of the horizontal extension 
TeLayer* espaco_cel = TeCreateCells("CellsEstados", estados,
			estados->box().width() / 100,
			estados->box().width() / 100,
			estados->box(), true); 

• geom_id: integer, the unique identification of the geometry;
• object_id: string, stores the unique identification of the object associated to the geometry;
• spatial_data: stores the geometrical data. The type of this field depends on the DBMS where the data is being stored. In DBMS's with spatial extension, the type is the type provided by the extension, otherwise it is a BLOB.

Polygons Table - without spatial extension		Polygons Table - with spatial extension (PostGIS)

Lines Table - without spatial extension		Lines Table - with spatial extension (PostGIS)

Points Table - without spatial extension		Points Table - with spatial extension (PostGIS)

TeLayer* distritos = new TeLayer("Distritos");
if (!db->loadLayer(distritos))
{
	cout << "Error loading layer \"Distritos\": " 
           << db->errorMessage() << endl << endl;
	db->close();
	return 1;
}

// Check if the table already exists in the database
string pointsTableName = distritos->tableName(TePOINTS);
if (pointsTableName.empty() == false)
{
	if (db->tableExist(pointsTableName))
	{
		cout << "The table \"" << pointsTableName 
                << "\" already exists in the database!\n\n";  
		db->close();
		return 1;
	}
}
TeRepresentation* repPol = distritos->getRepresentation(TePOLYGONS);
TePointSet centroids; 	// generate the centroids
if (db->Centroid(repPol->tableName_, TePOLYGONS, centroids) == false)
{
	cout << "Error creating centroids: " << db->errorMessage();  
	db->close();
	return 1;
}
//  Adds a geometric representation tot he layer
distritos->addPoints(centroids);
cout << "Centroides criados!\n\n"; 
cout <<"\nNumber of polygons "<< distritos->nGeometries(TePOLYGONS); 
cout <<"\nNumero of lines: "   << distritos->nGeometries(TeLINES);
cout <<"\nNumero of points " << distritos ->nGeometries(TePOINTS);

// Create the list of attributes
TeAttributeList attList;
TeAttribute at;
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = 16;
at.rep_.name_ = "IdObjeto";
at.rep_.isPrimaryKey_ = true;
attList.push_back(at);

at.rep_.type_ = TeSTRING;       	// a string attribute
at.rep_.numChar_ = 255;
at.rep_.name_ = "nome";
at.rep_.isPrimaryKey_ = false;
attList.push_back(at);  

at.rep_.type_ = TeREAL; 		// a real attribute 
at.rep_.name_ = "val1";
at.rep_.isPrimaryKey_ = false;
attList.push_back(at);  

// Creates an instance of attribute table in memory
TeTable attTable("teste2Attr",attList,"IdObjeto","IdObjeto");
TeTableRow row;
row.push_back("reta");
row.push_back("L reta");
row.push_back("11.1");
attTable.add(row);
row.clear();
row.push_back("ele");
row.push_back("L ele");
row.push_back("22.2");
attTable.add(row);
row.clear();
row.push_back("spoli");
row.push_back("Pol simples");
row.push_back("33.3");
attTable.add(row);
row.clear();
row.push_back("ponto1");
row.push_back("Um ponto");
row.push_back("55.5");
attTable.add(row);
row.clear();
row.push_back("cpoli");
row.push_back("Pol buraco");
row.push_back("44.4");
attTable.add(row);
row.clear(); 

string filename = "../data/BairrosRecife.MIF";
if (db->layerExist("BairrosRecife"))
{
	cout << "Error: the layer\"BairrosRecife\" already exists in the database!\n" << endl;
	db->close();
	return 1;
}
// Imports the MID/MIF file
TeLayer* newLayer = new TeLayer("BairrosRecife", db, 0);
// Select the attribute ID_ to be the object identification
if (TeImportMIF(newLayer, filename,"BairrosRecife", "ID_")) 
	cout << "The file was successfully imported!\n" << endl;
else
{
	cout << "Error importing the MID/MIF file!\n";
	db->close();
	return 1;
}
// Imports the CSV file
filename = "../data/BairrosRecife2.csv";
if (db->tableExist("BairrosRecife2"))
{
	cout << "There is already a  \"BairrosRecife2\" table in the database!\n\n";
		return 1;
}
cout << "Importing a second attribute table from a CSV file...\n";
// Creates the definition of the columns represented in the CSV
TeAttributeList attList;
TeAttribute column1;
column1.rep_.name_  = "BAIRRO_ID";
column1.rep_.type_ = TeSTRING;
column1.rep_.isPrimaryKey_ = true;
column1.rep_.numChar_ = 32;
attList.push_back(column1);

TeAttribute column2;
column2.rep_.name_  = "ORDEM";
column2.rep_.type_ = TeINT;
attList.push_back(column2);

TeAttribute column3;
column3.rep_.name_  = "NOME";
column3.rep_.type_ = TeSTRING;
column3.rep_.numChar_ = 32;
attList.push_back(column3);

TeAttribute column4;
column4.rep_.name_  = "NOME_PADRAO";
column4.rep_.type_ = TeSTRING;
column4.rep_.numChar_ = 32;
attList.push_back(column4);

TeTable attTable2("BairrosRecife2",attList, "BAIRRO_ID",
                      "BAIRRO_ID", TeAttrStatic);
if (!newLayer->createAttributeTable(attTable2))
{
	cout << "Error creating the table \"BairrosRecife2\" in the database!\n\n";
	return 1;
}
TeAsciiFile csvFile(filename);
while (csvFile.isNotAtEOF())
{
	TeTableRow trow;
	csvFile.readNStringCSV (trow, 4, ';');
	if (trow.empty())
		break;
	csvFile.findNewLine();
	attTable2.add(trow);
}
if (attTable2.size() > 0)
{
	if (!newLayer->saveAttributeTable(attTable2))
	{
		cout << "Error inserting the  \"BairrosRecife2\" table in the database  !\n\n";
		return 1;
	}
	attTable2.clear();
}
cout << "Table was successfully imported...\n";
db->close();

// Importing a dbf file
string filename = "../data/SOCEC.dbf";
if (db->tableExist("SOCEC"))
{
	cout << "There is already a table called \"SOCEC\" in the database!\n\n";
	return 1;
}
if (TeImportDBFTable(filename,db)) 
	cout << "The dbf file \"SOCEC.dbf\" was successfully imported to the database!\n\n";
else
{
	db->close();
	cout << "Fail to import the dbf file!\n";
	return 1;
}
TeAttrTableVector tableVec;
if (db->getAttrTables(tableVec, TeAttrExternal))
{	cout << "External tables in the database: "
            << tableVec.size() << endl;
	TeAttrTableVector::iterator it = tableVec.begin();
	while (it != tableVec.end())
	{  cout << (*it).name() << " Primary key column: " 
               << (*it).uniqueName() << endl << endl;
		++it;
	}
}
db->close();

// Create a projection
TeDatum mDatum = TeDatumFactory::make("SAD69");
TeProjection* pUTM = new TeUtm(mDatum,0.0);

// Create a new layer called "TesteLayer"
string layerName = "TesteLayer";
if (db->layerExist(layerName))
{
	cout << "There is already a layer called  \"TesteLayer\" in the database!\n\n";
	db->close();
	return 1;
}

TeLayer* layer = new TeLayer(layerName, db, pUTM);
if (layer->id() <= 0)      // The layer wasn't created correctly
{
	cout << "Error: " << db->errorMessage() << endl;
	db->close();
	return 1;
}

// Adds the line representation in a table called "TesteLayerLines"
if (!layer->addGeometry(TeLINES, "TesteLayerLines"))
{
	cout << "Error: " << db->errorMessage() << endl;
	db->close();
	return 1;
}

// Creates a set of lines
TeLine2D reta;
reta.add(TeCoord2D(500,500));
reta.add(TeCoord2D(600,500));
reta.add(TeCoord2D(700,500));
reta.objectId("reta");

TeLine2D ele;
ele.add(TeCoord2D(500,600));
ele.add(TeCoord2D(600,600));
ele.add(TeCoord2D(700,700));
ele.add(TeCoord2D(800,600));
ele.add(TeCoord2D(900,600));
ele.objectId("ele");

TeLineSet ls;
ls.add(reta);
ls.add(ele);

// Adds the set of lines to the database
if (!layer->addLines(ls))
{
	cout << "Error: " << db->errorMessage() << endl;
	db->close();
	return 1;
}
else
cout << "Lines inserted in the new layer\n";

//Created a set of polygons
// A simple polygon
TeLine2D line;
line.add(TeCoord2D(900,900));
line.add(TeCoord2D(900,1000));
line.add(TeCoord2D(1000,1000));
line.add(TeCoord2D(1000,900));
line.add(TeCoord2D(900,900));
TeLinearRing r1(line);
TePolygon poly1;
poly1.add(r1);
poly1.objectId("spoli");

// A polygon with a hole
TeLine2D line2;
line2.add(TeCoord2D(200,200));
line2.add(TeCoord2D(200,400));
line2.add(TeCoord2D(400,400));
line2.add(TeCoord2D(400,200));
line2.add(TeCoord2D(200,200));

TeLinearRing r2(line2);

TeLine2D line3;
line3.add(TeCoord2D(250,250));
line3.add(TeCoord2D(250,300));
line3.add(TeCoord2D(300,300));
line3.add(TeCoord2D(300,250));
line3.add(TeCoord2D(250,250));

TeLinearRing r3(line3);

TePolygon poly2;
poly2.add(r2);
poly2.add(r3);
poly2.objectId("cpoli");

TePolygonSet ps;
ps.add(poly1);
ps.add(poly2);

// Adds the set of polygons to the layer. 
// As the method addGeometry wasn't called before, the table will have a standard name
if (!layer->addPolygons(ps))
{
	cout << "Error: " << db->errorMessage() << endl;
	db->close();
	return 1;
}
else
	cout << "Polygons inserted in the new layer!\n";

// Creates a set o points
TePoint p1(40,40);
p1.objectId("ponto1");
TePoint p2(65,65);
p2.objectId("ponto2");

TePointSet pos;
pos.add(p1);
pos.add(p2);
// Adds the set of points to the layer. 
// As the method addGeometry wasn't called before, the table will have a standard name
if (!layer->addPoints(pos))
{
	cout << "Error: " << db->errorMessage() << endl;
	db->close();
	return 1;
}
else
	cout << "Points inserted in the new layer!\n";

// Creates an attribute tables
// Defines the list of attributes
TeAttributeList attList;
TeAttribute at;
at.rep_.type_ = TeSTRING;
at.rep_.numChar_ = 16;
at.rep_.name_ = "object_id";
at.rep_.isPrimaryKey_ = true;
attList.push_back(at);

at.rep_.type_ = TeSTRING;       // an string attribute
at.rep_.numChar_ = 255;
at.rep_.name_ = "nome";
at.rep_.isPrimaryKey_ = false;
attList.push_back(at);  

at.rep_.type_ = TeREAL; // a float attribute
at.rep_.name_ = "val1";
at.rep_.isPrimaryKey_ = false;
attList.push_back(at);  

at.rep_.type_ = TeINT;          // an integer attribute
at.rep_.name_ = "val2";
at.rep_.isPrimaryKey_ = false;
attList.push_back(at);  

// Creates an attribute table called "TesteLayerAttr"
TeTable attTable("TesteLayerAttr", attList, "object_id", "object_id");		// creates the table in memory
if (!layer->createAttributeTable(attTable))
{
	cout << "Error: " << db->errorMessage() << endl << endl;
	db->close();
	return 1;
}


// each line is related to the object by the field object_id
TeTableRow row;
row.push_back("reta");
row.push_back("An straight line");
row.push_back("11.1");
row.push_back("11");
attTable.add(row);
row.clear();

row.push_back("ele");
row.push_back("A mountain shaped line");
row.push_back("22.2");
row.push_back("22");
attTable.add(row);
row.clear();

row.push_back("spoli");
row.push_back("A simple polygon");
row.push_back("33.3");
row.push_back("33");
attTable.add(row);

row.clear();
row.push_back("ponto1");
row.push_back("A point");
row.push_back("55.5");
row.push_back("55");
attTable.add(row);
row.clear();

row.push_back("ponto2");
row.push_back("Another point");
row.push_back("66.6");
row.push_back("66");
attTable.add(row);
row.clear();

row.push_back("cpoli");
row.push_back("A polygon with hole");
row.push_back("44.4");
row.push_back("44");
attTable.add(row);
row.clear();

// Saves the table in the database
if (!layer->saveAttributeTable( attTable ))
{
	cout << "Error: " << db->errorMessage() << endl << endl;
	db->close();
	return 1;
}
else
cout << "Objects inserted in the new layer!\n\n";

Figure 8.1 – Contents of the database after running the Example 8.1.

TePolygonSet ps2;
layer1->getPolygons(ps2);
cout << "Number of object with polygon geometry: " << ps2.size();
ps2.clear();
// retrieves only the objects with the identifier "spoli"
layer1->loadGeometrySet("spoli", ps2);

db->createConceptualModel(); // creates the conceptual model
// creates a table to store polygons
db->createPolygonGeometry("TablePoligonos"); 

// create a table to stores descriptive attributes
TeAttributeList meusAttributos;
TeAttribute coluna;
coluna.rep_.type_ = TeSTRING;
coluna.rep_.name_ = "coluna1";
coluna.rep_.numChar_ = 10;
meusAttributos.push_back(coluna);

db->createTable("TableAtributos", meusAttributos);

// creates a new column in a existing table
TeAttributeRep novaColuna;
novaColuna.type_ = TeSTRING;
novaColuna.name_ = "novaCol";
novaColuna.numChar_ = 10;
db->addColumn("TableAtributos", novaColuna);
// retrieves a layer
TeLayer *layer = new TeLayer("Distritos");
// loads the information about the layer called Distritos
db->loadLayer(layer);     
// removes the layer
db->deleteLayer(layer->id());  

TePolygonSet polyset;
db->insertPolygonSet("tabPoligono", polyset);

TeLineSet lineset;
db->insertLineSet	("tabLine", lineset);

TePointSet pointset;
db->insertPointSet("tabPoint", pointset);	

TeTable tabAttributes;
insertTable(tabAttributes);

string sql = "UPDATE TableAtributos SET novaCol = 'xxx' ";
if (db->execute(sql))
	cout << "SQL command executes successfully!";
else
	cout << "Error: " << db->errorMessage();

// Gets a portal to the database
TeDatabasePortal* portal = db->getPortal();
if (!portal)
	 return -1;

// Submit a SQL command
string sql = "SELECT * FROM TableAtributos";
if (!portal->query(sql))
{
	 cout << "Could not execute..." << db->errorMessage();
   delete portal;
   return -1;
}
// Consuming the resulting records
while (portal->fetchRow())
{
	 cout << "Attribute 1: " << portal->getData(0) << endl;
   cout << "Attribute 2: " << portal->getData("nome") << endl;
   cout << "Attribute 3: " << portal->getDouble(2) << endl;
}
// Releases the portal for a new query 
portal->freeResult();

// Submits a new query
sql = "SELECT SUM(val1) FROM TableAtributos WHERE val1 > 33.5";
if (portal->query(sql) && portal->fetchRow())
	 cout << "Sum " << portal->getDouble(0);
delete portal;

// Submit a query to a geometry table
string q =" SELECT * FROM Polygons11 WHERE object_id='cpoli'";
       q += " ORDER BY parent_id, num_holes DESC, ext_max ASC";

if (!portal->query(q) || !portal->fetchRow())
{
	delete portal;
	return false;
}
bool flag = true;
do
{
	TePolygon poly;
	flag = portal->fetchGeometry(poly);
	// uses the polygon that was returned 
} while (flag);
delete portal;

// Connects to a  MySQL server
//Loads the layer "Distritos" that contains the districts of São Paulo city
TeLayer* dist = new TeLayer("Distritos");
db->loadLayer(dist); 

TeProjection* proj = dist->projection(); 
// Creates a view with the same projection as the layer
string viewName = "SaoPaulo";
// Check if the view already exists in the database
if (db->viewExist(viewName))
{
	db->close();
	return 1;
}
TeView* view = new TeView(viewName, user); 
view->projection(proj);
if (!db->insertView(view))		// saves the view in the database
{
	db->close();
	return 1;
}
// creates a theme without restriction
TeTheme* theme = new TeTheme("DistritosSaoPaulo", dist);
view->add(theme);

// defines the geometry presentation visual
// Polygons will be blue
TeColor color;
TeVisual polygonVisual(TePOLYGONS);
color.init(0,0,255);
polygonVisual.color(color); 
theme->setVisualDefault(polygonVisual, TePOLYGONS);
// Points will be red
TeVisual pointVisual(TePOINTS);
color.init(255,0,0);
pointVisual.color(color);
pointVisual.style(TePtTypeX);
theme->setVisualDefault(pointVisual, TePOINTS);

// Make all the representations visible
int allRep = dist->geomRep();
theme->visibleRep(allRep);

// Theme will use all the attribute tables of the layer
theme->setAttTables(dist->attrTables());
// Saves the theme in the database
if (!theme->save())	
{
	db->close();
	return 1;
}

// Builds the collection table associated to the theme
if (!theme->buildCollection())
{
	db->close();
	return 1;
}
cout << "The theme \"DistritosSaoPaulo\" without restriction was created!\n";
// Creates a theme with attribute restriction:
// Districts with a population over 100,000 people

TeTheme* themeRest = new TeTheme("Pop91GT100000", dist);
themeRest->setAttTables (dist->attrTables());

// Sets the attribute restriction
string restAttr = " Pop91 > 100000 ";
themeRest->attributeRest(restAttr);
//  Make all the representations visible
themeRest->visibleRep(allRep);

// Defines the presentation visual
themeRest->setVisualDefault(polygonVisual, TePOLYGONS);
themeRest->setVisualDefault(pointVisual, TePOINTS);
// Insert theme in the view
view->add(themeRest);
// Save the theme to the database
if (!themeRest->save())
{
	db->close();
	return 1;
}

// Builds the collection table associated to the theme
if (!themeRest->buildCollection())
{
	db->close();
	return 1;
}
cout << "The theme  \"Pop91GT100000\" with an attribute restriction was created!\n\n";
db->close();

TeLayer* recife = new TeLayer("BairrosRecife",db);
TeTable attTable2;
recife->getAttrTablesByName("BairrosRecife2",attTable2);
TeView* viewrec = new TeView("Recife",user); 
viewrec->projection(recife->projection());
if (!db->insertView(viewrec))	// saves the view in the database
{
	cout << "Fail to insert the view  \"Recife\" no banco: " << 
             db->errorMessage() << endl;
	db->close();
	return 1;
}
TeTheme* themerec = new TeTheme("Recife", recife);
viewrec->add(themerec);
themerec ->addThemeTable(attTable2);
themerec->visibleRep(recife->geomRep());
if (!themerec->save() || !themerec->buildCollection()) 
{
	cout << "Error trying to create the theme \' Recife \': "
           << db->errorMessage() << endl;
	db->close();
	return 1;
}
cout << "Theme created ..\n";
db->close();

// Load the theme DistritosSaoPaulo.
// Created with a layer of the metropolitan districts of São Paulo
TeTheme* trmsp = new TeTheme("DistritosSaoPaulo");
if (!db->loadTheme(trmsp))
{
	db->close();
	return 1;
}
trmsp->resetGrouping();	// Reset the grouping previously created

TeAttributeRep rep;			
// The grouping based on the attribute called "area_km2"
// that contains the area of the districts
rep.name_ = " area_km2 ";		
rep.type_ = TeREAL;

TeGrouping equalstep3;	// defines a way to group the objects
equalstep3.groupAttribute_ = rep;
equalstep3.groupMode_ = TeEqualSteps;	// equal steps in three groups
equalstep3.groupNumSlices_ = 3;

// generate the grouping
if (!trmsp->buildGrouping(&equalstep3))	
{
	db->close();
	return 1;
}   

// associates a different visual to each group
TeVisual visual(TePOLYGONS);		// group 1: dark green
TeColor color(0,200,0);
visual.color(color);
trmsp->setGroupingVisual(1,visual,TePOLYGONS);

color.init(0,150,0);
visual.color(color);		// group 2: green
trmsp->setGroupingVisual(2,visual,TePOLYGONS);

color.init(0,100,0);	
visual.color(color);		// group 3: light green
trmsp->setGroupingVisual(3,visual,TePOLYGONS);	

if (!trmsp->saveGrouping())		// saves the  grouping
{
	db->close();
	return 1;
}
db->close(); 

• TeRaster^[9]: generic class for handling raster data independent from format, size of each raster element or storage device. This class provides the setElement and getElement methods used for developing the applications.
• TeRasterParams:structure that stores all specific parameters of a particular raster. These parameters include: number of lines, columns and bands, type of element, number of bytes per element, projection, bounding box etc. EachTeRaster has a TeRasterParams.
• TeDecoder: class that allows the access to specific raster data. The decoder associated to raster data can be explicitly chosen or inferred from a parameter, for instance, extensions on raster data file names.

void show (TeRaster* rst)
{
    TeRasterParams params = rst->params();
    cout << "Nro Bands " << params.nBands() << endl;
    cout << "Nro Lines: " << params.nlines_ << endl;
    cout << "Nro Columns: " << params.ncols_ << endl;
    cout << "Projection " << params.projection()->name() << endl;
    double val;
    if (rst->getElement(45,2,val,0))
       cout << "value of the element of the line 2 and column 45: " << val << endl;
    if (rst->getElement(67,2,val,0))
       cout << "value of the element of the line 2 and column 67: " << val << endl;

    if (rst->getElement(300,2,val,0))
       cout << "value of the element of the line 2 and column 300 " << val <<endl;
	else
       cout << "there are no values at line 2 and column 300" << endl;
}

void main() 
{
	// initializes the decodification mechanism
	TeInitRasterDecoders();	
	// defines a projection
	TeProjection* noproj = new TeNoProjection();

	// defines the parameters of a raster data in memory
	TeRasterParams  params;		
	params.projection(noproj);			// projection
	params.setPhotometric(TeRasterParams::TeMultiBand);// photometric interpretation
	params.nBands(1);					// number of bands	
	params.setDataType(TeFLOAT);		// size of the element
	params.boundingBoxLinesColumns(0,0,99,99,100,100);
	params.decoderIdentifier_ = "MEM";	// righ decoder
	params.mode_ = 'c';					// openning for creation

	cout << "Box: [" << params.box().x1_ << ",";
	cout << params.box().y1_ << ",";
	cout << params.box().x2_ << ",";
	cout << params.box().y2_ << "]\n";
	cout << "Bounding Box: [" << params.boundingBox().x1_ << ",";
	cout << params.boundingBox().y1_ << ",";
	cout << params.boundingBox().x2_ << ",";
	cout << params.boundingBox().y2_  <<  "]\n\n";

	TeRaster* rastermem = new TeRaster(params);	
	rastermem->init();							 
	if (!rastermem->status())	
	{
		cout << "Error creating raster data in memory." << endl;
		return 1;
	}
	// put value in some elements
	for (int l=0; l<params.nlines_; ++l)
	{
		for (int c=0; c<params.ncols_; ++c)	
			rastermem->setElement(c,l,c+1);
	}
	show(rastermem);
}

void main() 
{
	// initializes the decodification mechanism
	TeInitRasterDecoders();	
	// defines the parameters of a raster data in a raw file
	TeRasterParams  params;		
	params.projection(noproj);	
	params.setPhotometric(TeRASTERMULTIBAND);	
	params.nBands(1);						
	params.setDataType(TeUNSIGNEDCHAR);
	// bounding box parameters
	params.topLeftResolutionSize(7404193,321045,30,30,589,703,true);	
	params.decoderIdentifier_ = "MEMMAP";
	params.fileName_ = "../data/sp_589x703.raw";
	params.mode_ = 'r';
	cout << "Box: [" << params.box().x1_ << ",";
	cout << params.box().y1_ << ",";
	cout << params.box().x2_ << ",";
	cout << params.box().y2_  <<  "]\n";
	cout << "Bounding Box: [" << params.boundingBox().x1_ << ",";
	cout  << params.boundingBox().y1_<< ","  ;
	cout << params.boundingBox().x2_ << "," ;
	cout << params.boundingBox().y2_  <<  "]\n\n";
	TeRaster* rasterraw = new TeRaster(params);					 
	if (!rasterraw->init())
	{
		cout << "Error reading raster data in a raw file." << endl;
		return;
	}
	 show(rasterraw);
}

void main() 
{
	// initializes the decodification mechanism
	TeInitRasterDecoders();
	TeRaster* rastertif = new TeRaster("../data/nat1.tif");	
	rastertif->init();						 
	if (!rastertif->status())	
	{
		cout << "Error initializing the data from the file." << endl;
		return;
	}
	cout << " \n --- Raster TIFF --- \n";
	show(rastertif);

	TeRaster* rasterjpg = new TeRaster("../data/ sampa.jpg");					 
	if (!rasterjpg ->init())	
	{
		cout << "Error initializing the data from the file." << endl;
		return;
	}
	cout << " \n --- Raster JPEG ---- \n";
	show(rasterjpg);
}

#include <TeDatabase.h>
#include <TeMySQL.h>
#include <TeInitRasterDecoders.h>
#include <TeImportRaster.h>
int main()
{
	TeInitRasterDecoders(); // initializes the decodification mechanism
	TeRaster image("../data/sampa.jpg"); // accessing the input image
	if (!image.init())
	{
		cout  << "Can not access the input image!" << endl;
		return 1;
	}
 	// server parameters
	string host = "localhost";
	string dbname = "TerraTeste";
	string user = "root";
	string password = "";
	TeDatabase* db = new TeMySQL();
	if (!db->connect(host, user, password, dbname))
	{
		image.clear();
		cout << "Error: " << db->errorMessage() << endl;
		return 1;
	}
	string layerName = "SampaJPEG";
	if (db->layerExist(layerName))
	{
		cout << "Database already has a layer called \"";
		cout << layerName << "\"!" << endl << endl;
		db->close();
		return 1;
	}
	// creates a layer to receive the raster geometry
	TeLayer* layer = new TeLayer(layerName, db, image.projection());
	if (layer->id() <= 0)
	{
		image.clear();
		db->close();
		cout << "Destination layer couldn't be created!\n" 
			<< db->errorMessage() << endl << endl;
		return 1;
	}
	// imports the raster to the layer
	if (!TeImportRaster(layer, &image, 128, 128))
	{
		image.clear();
		db->close();
		cout << "Fail to import image!\n" << endl;
		return 1;
	}
	db->close();
	cout << "JPEG image was imported!\n\n";
	return 0;
}

#include <TeDatabase.h>
#include <TeMySQL.h>
#include <TeInitRasterDecoders.h>
#include <TeImportRaster.h>
int main()
{
	TeInitRasterDecoders();	// initializes the decodification mechanism
	//access the first image
	TeRaster img1("../data/nat1.tif");
	if (!img1.init())
	{
		cout << "Can not access the first image!" << endl << endl;
		return 1;
	}
	TeRaster img2("../data/nat2.tif");
	if (!img2.init())
	{
		cout << "Can not access the second image!" << endl << endl;
		return 1;
	}
	string host = "localhost";
	string dbname = "TerraTeste";
	string user = "root";
	string password = "";

	TeDatabase* db = new TeMySQL();
	if (!db->connect(host, user, password, dbname))
	{
		cout << "Error: " << db->errorMessage() << endl << endl;
		return 1;
	}

	// creates a layer to receive the mosaic (same projection as the first image)
	string layerName = "NatividadeMosaic";
	if (db->layerExist(layerName))
	{
		db->close();
		cout << "Database already has a layer called \"";
		cout << layerName << "\"!" << endl << endl;
		return 1;
	}
	TeLayer* layer = new TeLayer(layerName, db, img1.projection());
	if (layer->id() <= 0)
	{
		db->close();
		cout << "Destination layer couldn't be created!\n" << db->errorMessage() << endl;
		return 1;
	}

	// import the first image to the layer
	if (!TeImportRaster(layer,&img1,256,256,TeRasterParams::TeNoCompression,"",255,
	                    true,TeRasterParams::TeExpansible))
	{
		db->close();
		cout << "Fail to import the first image.\n\n!";
		return 1;
	}
	else
		cout << "The first image was imported to the database!\n\n"; 

	delete layer;
	layer = new TeLayer(layerName, db);
		// mosaic the second image to the same layer	
	if (!TeImportRaster(layer, &img2, 256, 256, TeRasterParams::TeNoCompression, "", 255,
	                    true, TeRasterParams::TeExpansible))
	{
		db->close();
		cout << "Fail to import the second image.\n\n!";
		return 1;
	}
	else
		cout << "The second image was imported!"<< endl << endl;
	db->close();
	return 0;
}

TeLayer* brasLayer = new TeLayer("Brasilia", db); // retrieves the layer
TeRaster* bras = brasLayer->raster();	// retrieves the first raster
	
TeRaster* sul = brasLayer->raster("sul");	// geometry of the object "sul"
TeRaster* norte = brasLayer->raster("norte"); // geometry of the object "norte"

1. Determination of topological relationships among vector geometries: based on the 9-intersection dimensionally extended where some relationships are formalizes as touch, contain, within, covered by etc.
2. Metric operations: area calculation, length or perimeter and geometries distance.
3. Operations that generate new geometries: buffer (generates a new geometry around another geometry considering a certain distance), centroid and convex geometry.
4. Operations that combine geometries: such as difference, union, intersection or symmetrical difference.
5. Zonal and focal operations over raster data: as the obtaining of statistical measures over a region of the raster data and clipping of a raster area.

// defines a precision of the operations
TePrecision::instance().setPrecision(0.001);

// creating a polygon
TeLine2D line;
line.add(TeCoord2D(480275.38, 6667799.34));
line.add(TeCoord2D(483337.32, 6666464.65));
line.add(TeCoord2D(486006.70, 6668898.50));
line.add(TeCoord2D(484593.50, 6671410.86));
line.add(TeCoord2D(481688.58, 6672431.51));
line.add(TeCoord2D(480275.38, 6667799.34));
TeLinearRing ring(line);
TePolygon poly;
poly.add(ring);

//calculate the area 
double area = TeGeometryArea(poly);
//calculate the perimeter
double len = TeLength(ring);
//generate the centroid
TeCoord2D centroid = TeFindCentroid(poly);

//creating some points
TePointSet points;
TePoint point1(TeCoord2D(480000.38, 6667799.34));
point1.objectId ("point_1");
points.add (point1);
	 
TePoint point2(TeCoord2D(483180.30, 6668191.90));
point2.objectId ("point_2");
points.add (point2);

TePoint point3(TeCoord2D(483180.30, 6660000.90));
point3.objectId("point_3");
points.add (point3);

TePointSet::iterator it = points.begin();
while(it != points.end())
{
	if (TeWithin((*it), poly))
		cout << The point " << (*it).objectId() << " is inside the polygon." << endl ;
	++it;
}

// create polygon 1
TeLine2D line1;
line1.add(TeCoord2D(480275.38, 6667799.34));
line1.add(TeCoord2D(483337.32, 6666464.65));
line1.add(TeCoord2D(486006.70, 6668898.50));
line1.add(TeCoord2D(484593.50, 6671410.86));
line1.add(TeCoord2D(481688.58, 6672431.51));
line1.add(TeCoord2D(480275.38, 6667799.34));
TeLinearRing ring(line1);
TePolygon poly1;
poly1.add(ring);

// create polygon 2
TeLine2D line2;
line2.add(TeCoord2D(484000.00, 6668000.00));
line2.add(TeCoord2D(484000.00, 6670000.00));
line2.add(TeCoord2D(485000.00, 6670000.00));
line2.add(TeCoord2D(485000.00, 6668000.00));
line2.add(TeCoord2D(484000.00, 6668000.00));
TeLinearRing ring2(line2);
TePolygon poly2;
poly2.add(ring2);

TePolygonSet polSet1;
polSet1.add(poly1);
TePolygonSet polSet2;
polSet2.add(poly2);
TePolygonSet polSetResult;

// calculate the union of the polygons
bool res = TeOVERLAY::TeUnion(polSet1, polSet2, polSetResult);
polSetResult.clear();
// calculate the intersection between the polygons
res = TeOVERLAY::TeIntersection(polSet1, polSet2, polSetResult);

(a) Database without spatial extension	(b) Database with spatial extension

// retrieve the layers from the database
TeLayer* states = new TeLayer("states");	// states: polygons
db->loadLayer(states); 
TeLayer* rivers = new TeLayer("rivers");	// rivers: lines
db->loadLayer(rivers); 
TeLayer* cities = new TeLayer("cities");	// cities: points
db->loadLayer(cities);

vector<string> objsOut; // a vector to store the identification of the resulting objects	
vector<string> objsIn;  // a vector to store the identification of the object being consulted		
objsIn.push_back("23");

// defines a default precision according to the projection of the data
TePrecision::instance().setPrecision(TeGetPrecision(states->layer()->projection()));

// retrieves the states that touch the state 23
bool res = db->spatialRelation(states->tableName(TePOLYGONS), TePOLYGONS, objsIn, objsOut, TeTOUCHES);
if (res)
{
	cout << "States that touch the state \"23\": \n";
	unsigned int i;
	for (i=0; i<objsOut.size(); ++i)
		cout << "State " << objsOut[i] << endl;
}

// retrieves the rivers that touch the state 23
res = db->spatialRelation(states->tableName(TePOLYGONS), TePOLYGONS, objsIn,
		rivers->tableName(TeLINES), TeLINES, objsOut, TeCROSSES);
if(res)
{
	cout << "\nRivers that cross the state \"23\": \n";
	unsigned int i;
	for (i=0; i<objsOut.size(); i++)
		cout << "River " << objsOut[i] << endl;
}

// retrieves the cities that are inside the state 23
res = db->spatialRelation(states->tableName(TePOLYGONS), TePOLYGONS, 
		objsIn, cities->tableName(TePOINTS), TePOINTS, objsOut, TeWITHIN);
if (res)
{
	cout << "\nCities that are inside the state \"23\": \n";
	unsigned int i;
	for (i=0; i<objsOut.size(); i++)
		cout << "City " << objsOut[i] << endl;
}

db->close();
return 0;

//retrieves the layer with the neighborhoods"
TeLayer* bairros = new TeLayer("BairrosPoA");		
db->loadLayer(bairros);              
// retrieves the layers with the crime occurrences
TeLayer* events = new TeLayer("OcorrenciasPoA");	
db->loadLayer(events);
    

vector<string> objsOut;	// to store the identifier of the resulting occurrences
vector<string> objsIn;	 // the identifier of the object to queried		
objsIn.push_back("60");

TePrecision::instance().setPrecision(TeGetPrecision(bairros->projection()));

// generates the distance buffer
TePolygonSet bufferPol;
if (!db->buffer(bairros->tableName(TePOLYGONS), TePOLYGONS, objsIn, bufferPol, 500))
{
	cout << "Error generating the buffer!" << endl;
	return 1;
}
// retrieves the occurrences within the buffer
if(!db->spatialRelation(events->tableName(TePOINTS), TePOINTS, &bufferPol, objsOut, TeWITHIN))
{
	cout << "Error retrieving the events!" << endl;
	return 1;
}
>cout << " Crime occurrences within the buffer:" << endl << endl;

for(unsigned int i=0; i<objsOut.size(); i++)
	cout << "      " << objsOut[i] << endl;

db->close();
return 0;

//connect to the database
// initializes the raster decoding mechanism
TeInitRasterDecoders();

//loads the layer with the raster data
TeLayer* layerBrasilia =  new TeLayer("Brasilia_RGB",db);
string rasterTable =  layerBrasilia->tableName(TeRASTER);

//retrieves the polygon that will be used as the clipping mask
TeLayer* layerPolBrasilia = new TeLayer("BrasiliaPol", db);
TePolygonSet ps;
layerPolBrasilia->loadGeometrySet("0",ps);

//clips the raster data using the internal side of the mask, creating a new layer.
db->mask (layerBrasilia->tableName(TeRASTER), ps[0], "BrasiliaRecortadoIn", TeBoxPixelIn);

//clips the raster data using the external side of the mask, creating a new layer.
db->mask (rasterTable, poly, "BrasiliaRecortadoOut", TeBoxPixelOut);

//zonal operation: generates a series of measures within the mask
TeStatisticsDimensionVect result;
db->zonal(rasterTable, poly, result);

• Events: independent occurrences in space and time, that have a temporal label that says when the occurrence happened. For example, crimes that occur in a city on a certain date and location. Each occurrence has a unique identification in the database;
• Mutable objects: objects that have a geometry that do not change along the time, but that has a set of descriptive attributes that might change. For example, the data used by dynamic models based on cell spaces, or fixed measurement stations;
• Moving objects: data set where the attributes and the geometries of the objects can change along the time. For example, the data relative to the evolution of parcels of a city.

• Events: it has to register the name of attribute that uniquely identifies each object (and that links it to a geometry) and the fields that contains the time stamp associated to each event;
• Variable Attributes: it is related to a mutable objects. It has to register the name of attribute that uniquely identifies each object (and that links it to a geometry), the name of the attribute that uniquely identifies each instance in time of the object and the fields that contains the time stamp associated to each instance.

// shape file name with its path
string filename = "../data/EstadosBrasil.shp";

TeSTElementSet  steSet;
// fills the element set from shape file
if (!TeSTOSetBuildSHP(steSet,filename))
{
	cout << "Erro\n";
	return;
}
// prints the number of elements of the element set
cout << "Number of elements: " << steSet.numElements() << endl;
TeSTElementSet::iterator it = steSet.begin();
while ( it != steSet.end())
{
	TeSTInstance st = (*it);
	// returns the attributes
	TePropertyVector vectp = st.getPropertyVector();
	cout << "Id: " << st.objectId() << " ------------- " << endl; 
	for (unsigned int i=0; i<vectp.size(); i++)
	{
		cout << vectp[i].attr_.rep_.name_ << "  =  ";
		cout << vectp[i].value_ << endl;
	}
	cout << endl;
	++it;
}

// Connects to database ...	
// Loads a layer named BairrosPoA
TeLayer* estados =  new TeLayer("EstadosBrasil");
db_->loadLayer(estados);
    
//Inits querier strategies
TeInitQuerierStrategies();

// Creates a elementSet from the layer "estados"
TeSTElementSet steSet (estados);

// Defines what attributes will be kept in the elementSet. 
// The attribute name must be in the format 
// "table_name.attribute_name"
vector<string> attrs;
attrs.push_back("EstadosBrasil.NOME_UF");
attrs.push_back("EstadosBrasil.CAPITAL");

// Fills the elementSet without geometries and with the 
// attributes NOME_UF and CAPITAL
bool loadGeometries = false;
bool loadAllAttributes = false;
if(!TeSTOSetBuildDB(&steSet, loadGeometries, loadAllAttributes, attrs))
{
	cout << "Error! " << endl;
	cout << endl << "Press Enter\n";
	getchar();
	return 1;
}

// Prints the number of elements of the elementSet
cout << "Number of elements: " << steSet.numElements() << endl;

TeSTElementSet::iterator it = steSet.begin();
while ( it != steSet.end())
{
	TeSTInstance st = (*it);
	// returns the attributes
	TePropertyVector vectp = st.getPropertyVector();

	cout << "Id: " << st.objectId() << " ---------------- " << endl;
	for (unsigned int i=0; i<vectp.size(); i++)
	{
		cout << vectp[i].attr_.rep_.name_ << "  =  ";
		cout << vectp[i].value_ << endl;
	}
	cout << endl;
	++it;
}
db->close();

// Connects to TerraLib database...
// Loads a layer named BairrosPoA
TeLayer* bairrosPA =  new TeLayer("BairrosPoA");
db_->loadLayer(bairrosPA))

// Loads the geometry of Santo Antonio district (id = 48)
TePolygonSet ps;
bairrosPA->loadGeometrySet("48", ps ); 

// Loads a layer named OcorrenciaPoA 
TeLayer* OcorrenciaPoA =  new TeLayer("OcorrenciasPoA");
db->loadLayer(OcorrenciaPoA);

// Create a theme with restrictions from Ocorrencias layer, in memory
TeTheme* Ocorrencias = new TeTheme("Ocorrencias", OcorrenciaPoA);
TeAttrTableVector attrTables;
OcorrenciaPoA->getAttrTables(attrTables);
Ocorrencias->setAttTables(attrTables);

//spatial restriction: within Santo Antonio district
Ocorrencias->setSpatialRest (&ps, TePOINTS, TeWITHIN);
//attribute restriction: type "ameaça"
Ocorrencias->attributeRest(" EVENTO = 'Ameaça' ");

// Inits querier strategies
TeInitQuerierStrategies();
		
// Creates a elementSet from theme 
TeSTElementSet  steSet(Ocorrencias);

// Builds the elementSet with geometries and all attributes	
bool loadGeometries = true;
bool loadAllAttributes = true;
if(!TeSTOSetBuildDB(&steSet, loadGeometries, loadAllAttributes))
{
	cout << "Error! " << endl;
	cout << endl << "Press Enter\n";
	getchar();
	return 1;
}
// Shows how many elements the elementSet has
cout << "Number of elements: " <<  steSet.numElements() << endl;

TeSTElementSet::iterator it = steSet.begin();
while ( it != steSet.end())
{
	TeSTInstance st = (*it);
	//Gets attribute value
	string event;
	st.getPropertyValue("EVENTO", event);
	cout << " Object Identifier :  " << st.objectId() << endl; 
	cout << " Event	  :  " << event  << endl ; 
				
	//Gets geometry
	if(st.hasPoints())
	{
		TePointSet pset;
		st.getGeometry (pset);
		cout<< "     point id: "<< pset[0].objectId ()	 << endl;
		for(unsigned int j=0; j<pset.size (); ++j)
		{
			string point =  Te2String(pset[j].location().x()) + ";" + Te2String(pset[j].location().y());
			cout<< "		point: " << " ("+ point + ") "<< endl;
		}
	}
	++it;
}
db->close();
delete (Ocorrencias);

// Opens a connection to a TerraLib database 
// Load the layer
TeLayer* armadilhas = new TeLayer("LAYER_ARMADILHAS");
db_->loadLayer(armadilhas); 
		
bool loadAllAttributes = true;
bool loadGeometries = false;

//Init querier strategies
TeInitQuerierStrategies();

// Set querier parameters - load all attributes and 
// no geometries of the layer "armadilhas"
TeQuerierParams querierParams(loadGeometries, loadAllAttributes);
querierParams.setParams(armadilhas);
TeQuerier  querier(querierParams);

// Load instances from layer based in the querier parameters 
querier.loadInstances();

// Return a list of the loaded attributes  
TeAttributeList attrList = querier.getAttrList(); 
cout << " Loaded Attributes  -------------------  " << endl;
	
// Plot the attribute names 
for(unsigned int i=0; i<attrList.size(); ++i)
cout << attrList[i].rep_.name_ << endl; 
cout << endl;

// Traverse all the instances 
TeSTInstance sti;
while(querier.fetchInstance(sti))
{
	cout << " Object: " << sti.objectId() << endl << endl;
		
	// Plot each attribute, its name and value
	TePropertyVector vec = sti.getPropertyVector();
	for(unsigned int i=0; i<vec.size(); ++i)
	{
		string  attrName = vec[i].attr_.rep_.name_;
		string  attrValue = vec[i].value_;
		cout << attrName  << " : " << attrValue << endl;
	}
}
db_->close ();
return;

// Opens a connection to a TerraLib database 
// Load the layer "armadilhas"
		
bool loadGeometries = true;
vector<string> attributes;
attributes.push_back ("ARMADILHAS.COD_SITIO");
attributes.push_back ("ARMADILHAS.BAIRRO");

//Init querier strategies
TeInitQuerierStrategies();

// Set querier parameters - load only the attributes "COD_SITIO" 
// and "BAIRRO" and geometries of the layer "armadilhas"
TeQuerierParams querierParams(loadGeometries, attributes);
querierParams.setParams(armadilhas);
TeQuerier  querier(querierParams);

// Load instances from layer based in the querier parameters 
querier.loadInstances();

// Traverse all the instances 
TeSTInstance sti;
while(querier.fetchInstance(sti))
{
	cout << " Object: " << sti.objectId() <<  endl << endl;
	
	// Plot each attribute, its name and value
	TePropertyVector vec = sti.getPropertyVector();
	for(unsigned int i=0; i<vec.size(); ++i)
	{
		string  attrName = vec[i].attr_.rep_.name_;
		string  attrValue = vec[i].value_;
		cout << attrName  << " : " << attrValue << endl;
	}

	// Plot geometry
	if(sti.hasPoints())
	{
		TePointSet pointSet;
		sti.getGeometry(pointSet);

		for(unsigned int j=0; j<pointSet.size(); ++j)
			cout << " Point : ( "  << pointSet[j].location().x()
                   <<	"," << pointSet[j].location().y() << " )";
	}
	cout << endl << endl;
}
cout << " End " << endl;
getchar(); 
db_->close();
return;

// Connect to the database... 
//Load the theme "DistritosSaoPaulo"  	
TeTheme* bairros = new TeTheme("DistritosSaoPaulo");
db_->loadTheme(bairros);
		
// Init the querier mechanism
TeInitQuerierStrategies();

// All attributes and geometries
bool loadGeometries = true;
bool loadAllAttributes = true;
	
// Seta os parametros do querier - carrega todos os atributos e
// geometrias
TeQuerierParams querierParams(loadGeometries, loadAllAttributes);
querierParams.setParams(bairros);

TeQuerier  querier(querierParams);

// Load instances from layer based in the querier parameters
if(!querier.loadInstances())
	return 1;
// Traverse all the instances
TeSTInstance sti;
while(querier.fetchInstance(sti)) 
{
	cout << " Objeto: " << sti.objectId() << " ---- " << endl << endl;

	// Plot each attribute, its name and value
	TePropertyVector vec = sti.getPropertyVector();
	for(unsigned int i=0; i<vec.size(); ++i) 
	{
		string  attrName = vec[i].attr_.rep_.name_;
		string  attrValue = vec[i].value_;
		cout << attrName  << " : " << attrValue << endl;
	}
	//Get geometries	
	if(sti.hasPolygons())
	{
		TePolygonSet polSet;
		sti.getGeometry(polSet);
		for(unsigned int i=0; i<polSet.size(); ++i)
		{
			TeCoord2D centroid = TeFindCentroid(polSet[i]);
			string p = "( "+ Te2String(centroid.x(), 7) +", "+ 
                    Te2String(centroid.y(), 7) +")"; 
			cout << " Centroide do Poligono : " << p << endl; 
		}
	}
	if(sti.hasPoints()) 
	{
		TePointSet ponSet;
		sti.getGeometry(ponSet);
		for(unsigned int i=0; i<ponSet.size(); ++i)
		{
			string p = "( "+ Te2String(ponSet[i].location().x())
                       +", "+  Te2String(ponSet[i].location().y()) +")"; 
			cout << " Ponto : " << p << endl; 
		}
	}
	cout << endl << endl;
}
delete(bairros);
return 1;

// Connect to the database... 
// Load the Layer OcorrenciasBH
// Init the querier mechanism
TeInitQuerierStrategies();

// All attributes and geometries
bool loadGeometries = false;
bool loadAllAttributes = true;

// Define the querier parameters
TeQuerierParams querierParams(loadGeometries, loadAllAttributes);
querierParams.setParams(ocorrencias);

// Define the spatial restriction
TeBox box(609033.62, 794723.35, 613455.34, 800417.99); 
querierParams.setSpatialRest(box, TeWITHIN); 		

TeQuerier  querier(querierParams);

//Load instances from layer based in the querier parameters
querier.loadInstances();

// Traverse all the instances
TeSTInstance sti;
while(querier.fetchInstance(sti))
{
	cout << " Object: " << sti.objectId() << " ----- " << endl;
	// Plot each attribute, its name and value	
	TePropertyVector vec = sti.getPropertyVector();
	for(unsigned int i=0; i<vec.size(); ++i)
	{
		string  attrName = vec[i].attr_.rep_.name_;
		string  attrValue = vec[i].value_;
		cout << attrName  << " : " << attrValue << endl;
	}
	cout << endl << endl;
}
db_->close ();

// Connect to the database... 
// Loads the theme "OcorrenciasBH" 
// Loads the theme "BairrosBH" 
	
//Init the querier mechanism
TeInitQuerierStrategies();
	
// ------------ querier for the theme "bairros"
bool loadGeometries = true;
vector<string> attrs;
attrs.push_back ("Bairrobh.nobai");

TeQuerierParams querParamsBair(loadGeometries, attrs);
querParamsBair.setParams(bairros);
	
TeQuerier  querBairros(querParamsBair); 
if(!querBairros.loadInstances())
{
	cout << " There is no data!!! " << endl; 
	return 1;
}

// Loads each element and pass to query as a spatial restriction
TeSTInstance bairro;
while(querBairros.fetchInstance (bairro))
{
	string name;
	bairro.getPropertyValue(name, 0);
	cout << " Bairro: " << name << endl;
		
	TePolygonSet setP;
	if(!bairro.getGeometry (setP))  // access the polygon set
		continue;

	// ------------ querier for the theme ocorrências
	loadGeometries = false;
	vector<string>attributes;
	attributes.push_back ("ocorrenciasbh.Nrbo");
	TeQuerierParams querParamsOcr(loadGeometries, attributes);
	querParamsOcr.setParams(ocorrencias);
	
	// spatial restriction
	querParamsOcr.setSpatialRest(&setP);

	TeQuerier  querOcorrencias(querParamsOcr);
	if(!querOcorrencias.loadInstances())
	{
		cout << " There is no data!!! " << endl; 
		continue;
	}
	TeSTInstance sto;
	while(querOcorrencias.fetchInstance(sto)) 
	{
		// Plot each attribute, its name and value
		TePropertyVector vec = sto.getPropertyVector();
		for(unsigned int i=0; i<vec.size(); ++i)
		{
			string  attrName = vec[i].attr_.rep_.name_;
			string  attrValue = vec[i].value_;
				cout << attrName  << " : " << attrValue << endl;
		}
		// Mostra a data
		cout << endl << " Data : " << sto.getInitialDateTime();
             cout << endl;
	}
}
db_->close ();

// Connect to the database...
//Loads the theme "coletas" (the collects of eggs in the traps) 
		 
//Init the querier mechanism
TeInitQuerierStrategies();

// Selects a function to group the countings in each trap
bool loadGeometries = false;
TeGroupingAttr attributes;
	
pair<TeAttributeRep,TeStatisticType> attr1(TeAttributeRep("Coletas.NRO_OVOS_PAL1"), TeSUM);
attributes.insert(attr1);

pair<TeAttributeRep, TeStatisticType> attr2(TeAttributeRep("Coletas.NRO_OVOS_PAL2"), TeSUM);
attributes.insert(attr2);

pair<TeAttributeRep, TeStatisticType> attr3(TeAttributeRep("Coletas.NRO_OVOS_PAL3"), TeSUM);
attributes.insert(attr3);

pair<TeAttributeRep, TeStatisticType> attr4(TeAttributeRep("Coletas.NRO_OVOS"), TeSUM);
attributes.insert(attr4);

// Defines the querier parameters: loads only the grouped attributes
TeQuerierParams querierParams(loadGeometries, attributes);
querierParams.setParams(coletas);

TeQuerier  querier(querierParams);

// Loads the data from the layer based on the querier parameters
if(!querier.loadInstances())
{
	db_->close ();
	return;
}

// Traversal all instances
TeSTInstance sti;
while(querier.fetchInstance(sti))
{
	cout << " Object: " << sti.objectId()<< endl;
		
	// Plot each attribute, its name and value
	TePropertyVector vec = sti.getPropertyVector();
	for(unsigned int i=0; i<vec.size(); ++i)
	{
		string  attrName = vec[i].attr_.rep_.name_;
		string  attrValue = vec[i].value_;
		cout << attrName  << " : " << attrValue << endl;
	}
	cout << endl << endl;
}
db_->close();
return;

// Connects to the database and load the themes... 
TeTheme* coletas = new TeTheme("Coletas");
db_->loadTheme(coletas);
TeTheme* bairros = new TeTheme("ibge_bairros");  
db_->loadTheme(bairros);
		
TeInitQuerierStrategies();

// statistics about the counting
TeGroupingAttr attributes;
	
pair<TeAttributeRep, TeStatisticType> attr1(TeAttributeRep("Coletas.NRO_OVOS_PAL1"), TeSUM);
attributes.insert(attr1);

pair<TeAttributeRep, TeStatisticType> attr2(TeAttributeRep("Coletas.NRO_OVOS_PAL2"), TeSUM);
attributes.insert(attr2);

pair<TeAttributeRep, TeStatisticType> attr3(TeAttributeRep("Coletas.NRO_OVOS_PAL3"), TeSUM);
attributes.insert(attr3);

pair<TeAttributeRep, TeStatisticType> attr4(TeAttributeRep("Coletas.NRO_OVOS"), TeSUM);
attributes.insert(attr4);
	
// ------------ querier for the theme "bairros" (the districts)
bool loadGeometries = true;
vector<string> attrs;
attrs.push_back ("BAIRRO2000_REC.NOME");

TeQuerierParams querParamsBair(loadGeometries, attrs);
querParamsBair.setParams(bairros);

TeQuerier  querBairros(querParamsBair); 
if(!querBairros.loadInstances())
{
	cout << " there is no data!!! " << endl; 
	return;
}

// Loads each district passing its geometry as a spatial restriction
TeSTInstance bairro;
while(querBairros.fetchInstance (bairro))
{
	string name;
	bairro.getPropertyValue(name, 0);
	cout << " Bairro: " << name << endl;
			
	TePolygonSet setP;
	if(!bairro.getGeometry (setP))  // Access o polygon set
		continue;

	// ------------ querier for the theme "coletas"
	loadGeometries = false;

	TeQuerierParams querParamsCol(loadGeometries, attributes);
	querParamsCol.setParams(coletas);

	// spatial restriction
	querParamsCol.setSpatialRest(&setP);
	TeQuerier  querColetas(querParamsCol);
			
	if(!querColetas.loadInstances())
	{
		cout << " There is no data!!! " << endl; 
		continue;
	}
	TeSTInstance coleta;
	while(querColetas.fetchInstance(coleta)) 
	{
		// Plot each attribute, its name and value
		TePropertyVector vec = coleta.getPropertyVector();
		for(unsigned int i=0; i<vec.size(); ++i)
		{
			string  attrName = vec[i].attr_.rep_.name_;
			string  attrValue = vec[i].value_;
			cout << attrName  << " : " << attrValue << endl;
		}
	}
}
db_->close ();
return;

// Connects to the database and load the themes...>
TeInitQuerierStrategies();

// The grouping attribute 
bool loadGeometries = false;
TeGroupingAttr attributes;
	
pair<TeAttributeRep, TeStatisticType> attr1(TeAttributeRep("Coletas.NRO_OVOS_PAL1"), TeSUM);
attributes.insert(attr1);

pair<TeAttributeRep, TeStatisticType> attr2(TeAttributeRep("Coletas.NRO_OVOS_PAL2"), TeSUM);
attributes.insert(attr2);

pair<TeAttributeRep, TeStatisticType> attr3(TeAttributeRep("Coletas.NRO_OVOS_PAL3"), TeSUM);
attributes.insert(attr3);

pair<TeAttributeRep, TeStatisticType> attr4(TeAttributeRep("Coletas.NRO_OVOS"), TeSUM);
attributes.insert(attr4);

// Loads only the grouping attributes 
TeQuerierParams querierParams(loadGeometries, attributes);
querierParams.setParams(coletas, TeMONTH);

TeQuerier  querier(querierParams);
// Retrieves the number of time frames when seeing the data by TeMONTH
int numTimeFrames = querier.getNumTimeFrames();
	
// Loads all the instances in each time frame 
for(int frame=0; frame < numTimeFrames; ++frame)
{
	TeTSEntry ts;
	querier.getTSEntry(ts, frame);
			
	cout << " Time frame: " << Te2String(frame) <<  endl << endl;
	string initialDate = ts.time_.getInitialDateTime("DDsMMsYYYY"); 
	string finalDate = ts.time_.getFinalDateTime("DDsMMsYYYY");
			
	cout << " Time interval: " << initialDate << " to " << finalDate; 
	if(!querier.loadInstances(frame))
		continue;
					
	TeSTInstance sti;
	while(querier.fetchInstance(sti))
	{
		cout << " Object " << sti.objectId() << endl;
		TePropertyVector vec = sti.getPropertyVector();
		for(unsigned int i=0; i<vec.size(); ++i)
		{
			string  attrName = vec[i].attr_.rep_.name_;
			string  attrValue = vec[i].value_;
			cout << attrName  << " : " << attrValue << endl;
		}
	}
	cout << endl << endl;
} 
db_->close ();
return;

// Connect to the database and loads the layer of districts... 
TeLayer* DistritosSP = new TeLayer("DistritosSP");
db->loadLayer(DistritosSP);
	
// Init the querier strategies
TeInitQuerierStrategies();
    
// Create a empty STElementSet for the layer of districts
TeSTElementSet steSet(DistritosSP);

// Fills the STElementSet with the geometries
vector<string> attrs;
if(!TeSTOSetBuildDB(&steSet, true, false, attrs))
{
	cout << "Error! " << endl;
	return 1;
}

// Shows the number of elements in the set
cout << "Number of elements: " <<  steSet.numElements() << endl;

// Create a proximity matrix strategy
TeProxMatrixLocalDistanceStrategy<TeSTElementSet> sc_dist(&steSet,TePOLYGONS, 12000.00);
TeGeneralizedProxMatrix<TeSTElementSet> proxMat(&sc_dist);
proxMat.setCurrentConstructionStrategy(&sc_dist);

// Builds the proximity matrix
if(!proxMat.constructMatrix())
{
	cout << "Error creating the proximity matrix! " << endl;
	db->close ();
	return 1;
}

// Shows the neighbors of each district
TeSTElementSet::iterator it = steSet.begin();
while ( it != steSet.end())
{
	cout << " The neighbor of  "<< (*it).objectId() << "
                  are: " << endl;
	
	TeNeighboursMap neighbors = proxMat.getMapNeighbours((*it).objectId());
	TeNeighboursMap::iterator itN = neighbors.begin();
	while (itN != neighbors.end())	{
		cout<< "         "<<(*itN).first << endl;
		++itN;
	}
	cout << endl;
	++it;
}
db->close();

// Connect to the database and loads the layer of districts... 
TeLayer* DistritosSP =  new TeLayer("DistritosSP");
db->loadLayer(DistritosSP);

TeInitQuerierStrategies();

// Create a empty STElementSet for the layer of districts
TeSTElementSet steSet(DistritosSP);

// Fills the STElementSet only with the attribute "Pop91" to calculate the spatial statistics
vector<string> attrs;

attrs.push_back ("Distritos.Pop91");
if(!TeSTOSetBuildDB(&steSet, false, false, attrs)){
	cout << "Error! " << endl;
	return 1;
}
	
// Shows the number of elements in the set
cout << "Number of elements: " <<  steSet.numElements() << endl;

// Builds the proximity matrix
TeProxMatrixLocalAdjacencyStrategy sc_adj (&steSet,  TePOLYGONS);
TeGeneralizedProxMatrix<TeSTElementSet> proxMat(&sc_adj);
				
if (!proxMat.constructMatrix())
{
	cout << "Error building the proximity matrix! " << endl;
	return 1;
}

// Calculate a the global mean
double mean = TeFirstMoment (steSet.begin(), steSet.end(), 0); 
cout << "Média Global " << mean << endl << endl;

// Calculate the deviation (Z) for each object of the STElementSet
if(!TeDeviation (steSet.begin(), steSet.end(), mean))
{
	cout << "Error calculating Z! " << endl;
	return 1;
}   
	
// index for the attribute deviation (Z) in the STElementSet
int indexZ = 1;  

// Calculates the local mean (WZ) for each object of the STElementSet
if(!TeLocalMean (&steSet, &proxMat, indexZ))
{
	cout << "Error calculating the Local Mean! " << endl;
	return 1;
}

// index for the attribute Local Mean (WZ) in the STElementSet
int indexWZ = 2;

// Shows the Z and WZ indexes generated for each object
TeSTElementSet::iterator it = steSet.begin();
while ( it != steSet.end()){
	TeSTInstance obj = (*it);
	//Gets attribute value
	string valZ, valWZ;
	obj.getPropertyValue(valZ, indexZ);
	obj.getPropertyValue(valWZ, indexWZ);
	cout << " Identificador do Objeto :  " << obj.objectId() << endl; 
	cout << " Z		:  " << valZ   << endl; 
	cout << " WZ	:  " << valWZ  << endl << endl; 
	++it;
}

// Save the attributes (Z e WZ) in the table DistritosSP 
if(!TeUpdateDBFromSet (&steSet, "DistritosSP"))
{
	cout << "Error updating the database! " << endl;
	return 1;
}
db->close();