void AtomPropertyList::convertPropertyToFloat(int propertyNum) {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
//property num is valid
if (propertyIsInt[propertyNum]) {
//property is int -> convert
int intId = propertyId[propertyNum];
//change the bool flag to indicate a
propertyIsInt[propertyNum] = false;
//create a new float property
floatProperties.push_back(new std::vector<double>);
//save the corresponding id
propertyId[propertyNum] = floatProperties.size() - 1;
//
floatProperties.back()->resize(integerProperties[intId]->size());
//copy and convert all values from integer to float
for (int i = 0; i < integerProperties[intId]->size(); i ++) {
(*floatProperties.back())[i] =
static_cast<double>((*integerProperties[intId])[i]);
}
//delete the old property
delete integerProperties[intId];
integerProperties[intId] = nullptr;
}
}
}
void AtomPropertyList::addIntPropertyValue(int propertyNum, int value) {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
if (propertyIsInt[propertyNum]) {
//property is int
int intId = propertyId[propertyNum];
integerProperties[intId]->push_back(value);
}
}
}
void AtomPropertyList::addFloatPropertyValue(int propertyNum, double value) {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
if (!propertyIsInt[propertyNum]) {
//property is float
int floatId = propertyId[propertyNum];
floatProperties[floatId]->push_back(value);
}
}
}
/*!
* \brief This method creates a MockDataSet
* \return Returns a mocked DataSet that has the required behavior for unittests
*/
te::da::MockDataSet* createMockDataSet()
{
te::da::MockDataSet* mockDataSet(new te::da::MockDataSet());
EXPECT_CALL(*mockDataSet, moveNext()).WillRepeatedly(::testing::Return(true));
EXPECT_CALL(*mockDataSet, getAsString(::testing::An<const std::string&>(),::testing::_)).WillRepeatedly(::testing::Return(""));
EXPECT_CALL(*mockDataSet, getAsString(::testing::An<std::size_t>(),::testing::_)).WillRepeatedly(::testing::Return(""));
EXPECT_CALL(*mockDataSet, isNull(std::string())).WillRepeatedly(::testing::Return(false));
EXPECT_CALL(*mockDataSet, getNumProperties()).WillRepeatedly(::testing::Return(0));
EXPECT_CALL(*mockDataSet, moveFirst()).WillRepeatedly(::testing::Return(true));
return mockDataSet;
}
int AtomPropertyList::addProperty(const std::string & name, long reservedSize, bool isInteger) {
propertyNames.push_back(name);
propertyIsInt.push_back(isInteger);
if (isInteger) {
integerProperties.push_back(new std::vector<int>);
integerProperties.back()->reserve(reservedSize);
propertyId.push_back(integerProperties.size() - 1);
} else {
floatProperties.push_back(new std::vector<double>);
floatProperties.back()->reserve(reservedSize);
propertyId.push_back(floatProperties.size() - 1);
}
return getNumProperties() - 1;
}
int AtomPropertyList::getIntPropertyValue(int propertyNum, long atomNum) const {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
//property num is valid
if (propertyIsInt[propertyNum]) {
//property is int
int intId = propertyId[propertyNum];
if( atomNum < integerProperties[intId]->size() ) {
//a value for the atom exists
return (*integerProperties[intId])[atomNum];
}
}
}
//otherwise return an arbitrary value
return 0;
}
double AtomPropertyList::getFloatPropertyValue(int propertyNum, long atomNum) const {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
//property num is valid
if (!propertyIsInt[propertyNum]) {
//property is float
int floatId = propertyId[propertyNum];
if( atomNum < floatProperties[floatId]->size() ) {
//a value for the atom exists
return (*floatProperties[floatId])[atomNum];
}
}
}
//otherwise return an arbitrary value
return 0.0;
}
void aiSchemaBase::setupProperties()
{
auto cpro = getAbcProperties();
if (!cpro.valid()) { return; }
size_t n = cpro.getNumProperties();
for (size_t i = 0; i < n; ++i) {
auto header = cpro.getPropertyHeader(i);
auto *prop = aiMakeProperty(this, cpro, header);
if (prop != nullptr) {
m_properties.emplace_back(prop);
}
}
std::sort(m_properties.begin(), m_properties.end(),
[](aiPropertyPtr& a, aiPropertyPtr& b) { return a->getName() < b->getName(); });
}
//-*****************************************************************************
void CpwData::writePropertyHeaders( MetaDataMapPtr iMetaDataMap )
{
// pack in child header and other info
std::vector< Util::uint8_t > data;
for ( size_t i = 0; i < getNumProperties(); ++i )
{
PropertyHeaderPtr prop = m_propertyHeaders[i];
WritePropertyInfo( data,
prop->header,
prop->isScalarLike,
prop->isHomogenous,
prop->timeSamplingIndex,
prop->nextSampleIndex,
prop->firstChangedIndex,
prop->lastChangedIndex,
iMetaDataMap );
}
if ( !data.empty() )
{
m_group->addData( data.size(), &( data.front() ) );
}
}
int main(int argc, char* argv[])
{
terrama2::core::initializeTerraMA();
{
QUrl uri;
uri.setScheme("postgis");
uri.setHost(QString::fromStdString(TERRAMA2_DATABASE_HOST));
uri.setPort(std::stoi(TERRAMA2_DATABASE_PORT));
uri.setUserName(QString::fromStdString(TERRAMA2_DATABASE_USERNAME));
uri.setPassword(QString::fromStdString(TERRAMA2_DATABASE_PASSWORD));
uri.setPath(QString::fromStdString("/"+TERRAMA2_DATABASE_DBNAME));
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = uri.url().toStdString();
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "POSTGIS";
dataProvider->active = true;
//DataSeries information
terrama2::core::DataSeries* dataSeries = new terrama2::core::DataSeries();
terrama2::core::DataSeriesPtr dataSeriesPtr(dataSeries);
auto& semanticsManager = terrama2::core::SemanticsManager::getInstance();
dataSeries->semantics = semanticsManager.getSemantics("OCCURRENCE-postgis");
//DataSet information
terrama2::core::DataSetOccurrence* dataSet = new terrama2::core::DataSetOccurrence();
dataSet->active = true;
dataSet->format.emplace("table_name", "fires");
dataSet->format.emplace("timestamp_property", "data_pas");
dataSet->format.emplace("geometry_property", "geom");
dataSeries->datasetList.emplace_back(dataSet);
//accessing data
terrama2::core::DataAccessorOccurrencePostGis accessor(dataProviderPtr, dataSeriesPtr);
//empty filter
terrama2::core::Filter filter;
boost::local_time::time_zone_ptr zone(new boost::local_time::posix_time_zone("+00"));
filter.lastValue = true;
std::string boundingBoxWkt = "POLYGON((-51.11 -17.74, -41.11 -17.74, -41.11 -20.83, -51.11 -20.83, -51.11 -17.74))";
te::gm::Geometry* geometry = te::gm::WKTReader::read(boundingBoxWkt.c_str());
geometry->setSRID(4326);
filter.region = std::shared_ptr<te::gm::Geometry>(geometry);
terrama2::core::OccurrenceSeriesPtr occurrenceSeries = accessor.getOccurrenceSeries(filter);
assert(occurrenceSeries->occurrencesMap().size() == 1);
auto teDataSet = (*occurrenceSeries->occurrencesMap().begin()).second.syncDataSet->dataset();
//Print column names and types (DateTime/Double)
int dateColumn = -1;
int geomColumn = -1;
std::string names, types;
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
std::string name = teDataSet->getPropertyName(i);
names+= name + "\t";
if(name == "data_pas")
{
types+= "DataTime\t";
dateColumn = i;
}
else if(name == "geom")
{
types+= "Geometry\t";
geomColumn = i;
}
else
types+= "Int\t";
}
std::cout << names << std::endl;
std::cout << types << std::endl;
//Print values
teDataSet->moveBeforeFirst();
while(teDataSet->moveNext())
{
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
if(teDataSet->isNull(i))
{
std::cout << "NULL";
continue;
}
if(i == dateColumn)
{
std::shared_ptr<te::dt::DateTime> dateTime = teDataSet->getDateTime(i);
std::cout << dateTime->toString();
}
else if(i == geomColumn)
{
std::cout << "<<Geometry>>";
}
else
{
std::cout << teDataSet->getInt32(i);
}
std::cout << "\t";
}
std::cout << std::endl;
}
std::cout << "\ndataset size: " << teDataSet->size() << std::endl;
}
terrama2::core::finalizeTerraMA();
return 0;
}
bool AtomPropertyList::isPropertyInt(int propertyNum) const {
if ( propertyNum >= 0 && propertyNum < getNumProperties()) {
return propertyIsInt[propertyNum];
}
return true;
}
