dimension_size_type
FormatWriter::getSizeX() const
{
dimension_size_type series = getSeries();
dimension_size_type sizeX = metadataRetrieve->getPixelsSizeX(series);
if (sizeX == 0U)
sizeX = 1U;
return sizeX;
}
void
MinimalTIFFWriter::setSeries(dimension_size_type series) const
{
const dimension_size_type currentSeries = getSeries();
detail::FormatWriter::setSeries(series);
if (currentSeries != series)
{
nextIFD();
setupIFD();
}
}
dimension_size_type
FormatWriter::getRGBChannelCount(dimension_size_type channel) const
{
dimension_size_type series = getSeries();
dimension_size_type samples = 1U;
try
{
samples = metadataRetrieve->getChannelSamplesPerPixel(series, channel);
}
catch (const MetadataException& e)
{
// No SamplesPerPixel; default to 1.
}
return samples;
}
int ScripMasterDataRequest::serialize(char *buf)
{
int bytes = 0;
UNSIGNED_INTEGER tmp = 0;
UNSIGNED_SHORT tmpShort = 0;
UNSIGNED_CHARACTER tmpChar = 0;
UNSIGNED_LONG tmpLong = 0;
bytes = sizeof(UNSIGNED_SHORT); // Leave 2 bytes for packet size
// Put category of command
SERIALIZE_8(tmpChar, (UNSIGNED_CHARACTER)(CMD::CommandCategory_SEND_SCRIP_MASTER_DATA), buf, bytes); //Command Category
// Put fields of this class
SERIALIZE_8(tmpChar, getScripMasterDataRequestType(), buf, bytes);
SERIALIZE_32(tmp, getClientId(), buf, bytes);
SERIALIZE_64(tmpLong, getRecordNumber(), buf, bytes);
SERIALIZE_64(tmpLong, getSecurityId(), buf, bytes);
SERIALIZE_64(tmpLong, getSymbolId(), buf, bytes);
SERIALIZE_16(tmpShort, getExchangeId(), buf, bytes);
memcpy(buf + bytes, getSymbol(), SYMBOL_SIZE);
bytes += SYMBOL_SIZE;
memcpy(buf + bytes, getSeries(), SERIES_SIZE);
bytes += SERIES_SIZE;
memcpy(buf + bytes, getMarketName(), SERIES_SIZE);
bytes += MARKET_NAME_SIZE;
SERIALIZE_8(tmpChar, getOptionType(), buf, bytes);
SERIALIZE_8(tmpChar, getOptionMode(), buf, bytes);
SERIALIZE_8(tmpChar, getSecurityType(), buf, bytes);
SERIALIZE_64(tmpLong, getStrikePrice(), buf, bytes);
SERIALIZE_32(tmp, getExpiryYearMon(), buf, bytes);
SERIALIZE_32(tmp, getExpiryDate(), buf, bytes);
SERIALIZE_32(tmp, getNumberOfRecords(), buf, bytes);
memcpy(buf + bytes, getSymbolAlias(), SYMBOL_ALIAS_SIZE);
bytes += SYMBOL_ALIAS_SIZE;
UNSIGNED_SHORT dummyBytes = 0;
// Put size as the first field after deducting 2 bytes reserved for size
SERIALIZE_16(tmpShort, (UNSIGNED_SHORT)(bytes-sizeof(UNSIGNED_SHORT)), buf, dummyBytes);
return bytes;
}
bool terrama2::services::alert::core::AdditionalDataHelper::prepareData(terrama2::core::Filter filter)
{
auto dataAccessor = terrama2::core::DataAccessorFactory::getInstance().make(dataProvider_, dataSeries_);
dataMap_ = dataAccessor->getSeries(filter, remover_);
if(dataMap_.empty())
{
TERRAMA2_LOG_WARNING() << QObject::tr("No data to available in dataseries %1.").arg(additionalData_.id);
return false;
}
for(const auto& data : dataMap_)
{
const auto& dataSetSeries = data.second;
auto mapper = std::make_shared<terrama2::core::DataSetMapper>(dataSetSeries.syncDataSet->dataset(), additionalData_.identifier);
mapperMap_.emplace(data.first, mapper);
}
isDataReady_ = true;
return true;
}
std::set<std::string> terrama2::services::analysis::core::verify::dataAvailable(DataManagerPtr dataManager, AnalysisPtr analysis)
{
std::set<std::string> vecMessages;
for(auto& analysisDataSeries : analysis->analysisDataSeriesList)
{
auto dataSeries = dataManager->findDataSeries(analysisDataSeries.dataSeriesId);
auto dataProvider = dataManager->findDataProvider(dataSeries->dataProviderId);
auto dataAccesor = terrama2::core::DataAccessorFactory::getInstance().make(dataProvider, dataSeries);
try
{
terrama2::core::Filter filter;
auto series = dataAccesor->getSeries(filter, nullptr);
if(series.empty())
{
QString errMsg = QObject::tr("No data available for data series '%1'.").arg(dataSeries->name.c_str());
TERRAMA2_LOG_WARNING() << errMsg;
vecMessages.insert(vecMessages.end(), errMsg.toStdString());
}
}
catch(const terrama2::core::NoDataException&)
{
QString errMsg = QObject::tr("No data available for data series '%1'.").arg(dataSeries->name.c_str());
TERRAMA2_LOG_WARNING() << errMsg;
vecMessages.insert(vecMessages.end(), errMsg.toStdString());
}
catch(const terrama2::Exception& e)
{
std::string errMsg = boost::get_error_info<terrama2::ErrorDescription>(e)->toStdString();
vecMessages.insert(vecMessages.end(), errMsg);
TERRAMA2_LOG_ERROR() << errMsg;
}
}
return vecMessages;
}
void
MinimalTIFFWriter::saveBytes(dimension_size_type plane,
VariantPixelBuffer& buf,
dimension_size_type x,
dimension_size_type y,
dimension_size_type w,
dimension_size_type h)
{
assertId(currentId, true);
setPlane(plane);
dimension_size_type expectedIndex =
tiff::ifdIndex(seriesIFDRange, getSeries(), plane);
if (ifdIndex != expectedIndex)
{
boost::format fmt("IFD index mismatch: actual is %1% but %2% expected");
fmt % ifdIndex % expectedIndex;
throw FormatException(fmt.str());
}
ifd->writeImage(buf, x, y, w, h);
}
void ScripMasterDataRequest::dump()
{
std::cout << "ScripMasterDataRequest dump : " << std::endl;
std::cout << getScripMasterDataRequestType() << std::endl;
std::cout << getClientId() << std::endl;
std::cout << getRecordNumber() << std::endl;
std::cout << getSecurityId() << std::endl;
std::cout << getSymbolId() << std::endl;
std::cout << getExchangeId() << std::endl;
std::cout << getSymbol() << std::endl;
std::cout << getSeries() << std::endl;
std::cout << getMarketName() << std::endl;
std::cout << getOptionType() << std::endl;
std::cout << getOptionMode() << std::endl;
std::cout << getSecurityType() << std::endl;
std::cout << getStrikePrice() << std::endl;
std::cout << getExpiryYearMon() << std::endl;
std::cout << getExpiryDate() << std::endl;
std::cout << getNumberOfRecords() << std::endl;
std::cout << getSymbolAlias() << std::endl;
std::cout << "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" << std::endl;
}
void
FormatWriter::setSeries(dimension_size_type series) const
{
assertId(currentId, true);
if (series >= getSeriesCount())
{
boost::format fmt("Invalid series: %1%");
fmt % series;
throw std::logic_error(fmt.str());
}
const dimension_size_type currentSeries = getSeries();
if (currentSeries != series &&
(series > 0 && currentSeries != series - 1))
{
boost::format fmt("Series set out of order: %1% (currently %2%)");
fmt % series % currentSeries;
throw std::logic_error(fmt.str());
}
this->series = series;
this->plane = 0U;
}
std::set<std::string> terrama2::services::analysis::core::verify::attributeIdentifier(DataManagerPtr dataManager, AnalysisPtr analysis)
{
std::set<std::string> vecMessages;
if(analysis->type == AnalysisType::MONITORED_OBJECT_TYPE)
{
for(auto analysisDataSeries : analysis->analysisDataSeriesList)
{
if(analysisDataSeries.type == AnalysisDataSeriesType::DATASERIES_MONITORED_OBJECT_TYPE)
{
auto dataSeries = dataManager->findDataSeries(analysisDataSeries.dataSeriesId);
auto dataProvider = dataManager->findDataProvider(dataSeries->dataProviderId);
std::string identifier = analysisDataSeries.metadata["identifier"];
auto dataAccesor = terrama2::core::DataAccessorFactory::getInstance().make(dataProvider, dataSeries);
try
{
terrama2::core::Filter filter;
auto series = dataAccesor->getSeries(filter, nullptr);
if(!series.empty())
{
auto it = series.begin();
if(it != series.end())
{
if(!it->second.teDataSetType)
{
QString errMsg = QObject::tr("Could not read dataset type for data series '%1'.").arg(dataSeries->name.c_str());
TERRAMA2_LOG_WARNING() << errMsg;
vecMessages.insert(vecMessages.end(), errMsg.toStdString());
}
auto property = it->second.teDataSetType->getProperty(identifier);
if(property == nullptr)
{
QString errMsg = QObject::tr("Could not find the attribute identifier '%1' in data series '%2'.").arg(QString::fromStdString(identifier), QString::fromStdString(dataSeries->name));
TERRAMA2_LOG_WARNING() << errMsg;
vecMessages.insert(vecMessages.end(), errMsg.toStdString());
}
}
else
{
throw new terrama2::core::NoDataException();
}
}
}
catch(const terrama2::core::NoDataException&)
{
QString errMsg = QObject::tr("No data available for data series '%1'.").arg(dataSeries->name.c_str());
TERRAMA2_LOG_WARNING() << errMsg;
vecMessages.insert(vecMessages.end(), errMsg.toStdString());
}
catch(const terrama2::Exception& e)
{
std::string errMsg = boost::get_error_info<terrama2::ErrorDescription>(e)->toStdString();
vecMessages.insert(vecMessages.end(), errMsg);
TERRAMA2_LOG_ERROR() << errMsg;
}
}
}
}
return vecMessages;
}
void terrama2::services::view::core::makeView(ViewId viewId, std::shared_ptr< terrama2::services::view::core::ViewLogger > logger, std::weak_ptr<DataManager> weakDataManager)
{
auto dataManager = weakDataManager.lock();
if(!dataManager.get())
{
TERRAMA2_LOG_ERROR() << QObject::tr("Unable to access DataManager");
return;
}
try
{
RegisterId logId = 0;
if(logger.get())
logId = logger->start(viewId);
TERRAMA2_LOG_DEBUG() << QObject::tr("Starting view %1 generation.").arg(viewId);
auto lock = dataManager->getLock();
auto viewPtr = dataManager->findView(viewId);
if(viewPtr->dataSeriesList.size() != viewPtr->filtersPerDataSeries.size())
{
QString message = QObject::tr("View %1 do not have the right number of filters for data.").arg(viewId);
if(logger.get())
logger->error(message.toStdString(), viewId);
TERRAMA2_LOG_ERROR() << message;
throw Exception() << ErrorDescription(message);
}
std::vector<std::unordered_map<terrama2::core::DataSetPtr, terrama2::core::DataSetSeries>> seriesList;
for(auto dataSeriesId : viewPtr->dataSeriesList)
{
terrama2::core::DataSeriesPtr inputDataSeries = dataManager->findDataSeries(dataSeriesId);
terrama2::core::DataProviderPtr inputDataProvider = dataManager->findDataProvider(inputDataSeries->dataProviderId);
auto dataAccessor = terrama2::core::DataAccessorFactory::getInstance().make(inputDataProvider, inputDataSeries);
terrama2::core::Filter filter(viewPtr->filtersPerDataSeries.at(dataSeriesId));
std::unordered_map<terrama2::core::DataSetPtr, terrama2::core::DataSetSeries > series = dataAccessor->getSeries(filter);
seriesList.push_back(series);
}
lock.unlock();
if(seriesList.size() > 0)
{
drawSeriesList(viewId, logger, seriesList, viewPtr->resolutionWidth, viewPtr->resolutionHeight, viewPtr->srid);
TERRAMA2_LOG_INFO() << QObject::tr("View %1 generated successfully.").arg(viewId);
}
else
{
QString message = QObject::tr("View %1 has no associated data to be generated.").arg(viewId);
if(logger.get())
logger->info(message.toStdString(), viewId);
TERRAMA2_LOG_INFO() << message;
}
if(logger.get())
logger->done(terrama2::core::TimeUtils::nowUTC(), logId);
}
catch(const terrama2::Exception& e)
{
TERRAMA2_LOG_ERROR() << boost::get_error_info<terrama2::ErrorDescription>(e) << std::endl;
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(const boost::exception& e)
{
TERRAMA2_LOG_ERROR() << boost::get_error_info<terrama2::ErrorDescription>(e);
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(const std::exception& e)
{
TERRAMA2_LOG_ERROR() << e.what();
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(...)
{
TERRAMA2_LOG_ERROR() << QObject::tr("Unkown error.");
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
}
int main(int, char**)
{
terrama2::core::TerraMA2Init terramaRaii("example", 0);
terrama2::core::registerFactories();
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = "file://";
dataProvider->uri+=TERRAMA2_DATA_DIR;
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "FILE";
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("DCP-generic");
terrama2::core::DataSetDcp* dataSet = new terrama2::core::DataSetDcp();
dataSet->active = true;
dataSet->format.emplace("folder", "/pcd_toa5/CPV/");
dataSet->format.emplace("mask", "CPV_slow_%YYYY_%MM_%DD_%hh%mm.dat");
dataSet->format.emplace("timezone", "+00");
dataSet->format.emplace("srid", "4326");
dataSet->format.emplace("header_size", "4");
dataSet->format.emplace("properties_names_line", "2");
dataSet->format.emplace("convert_all", "true");
dataSet->format.emplace("default_type", "TEXT");
QJsonArray fields;
{
QJsonObject obj;
obj.insert("property_name", QString("TIMESTAMP"));
obj.insert("alias", QString("datetime"));
obj.insert("type", QString("DATETIME"));
obj.insert("format", QString("%YYYY-%MM-%DD %hh:%mm:%ss"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("RECORD"));
obj.insert("alias", QString("record"));
obj.insert("type", QString("INTEGER"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("E_field_Avg"));
obj.insert("alias", QString("efield"));
obj.insert("type", QString("INTEGER"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("panel_temp_Avg"));
obj.insert("alias", QString("panel"));
obj.insert("type", QString("INTEGER"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("leakage_cur_Avg"));
obj.insert("alias", QString("leak"));
obj.insert("type", QString("FLOAT"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("battery_volt_Avg"));
obj.insert("alias", QString("bateria"));
obj.insert("type", QString("FLOAT"));
fields.push_back(obj);
}
{
QJsonObject obj;
obj.insert("property_name", QString("internal_RH_Avg"));
obj.insert("alias", QString("interval"));
obj.insert("type", QString("TEXT"));
fields.push_back(obj);
}
QJsonObject obj;
obj.insert("fields", fields);
QJsonDocument doc(obj);
dataSet->format.emplace("fields", QString(doc.toJson(QJsonDocument::Compact)).toStdString());
dataSeries->datasetList.emplace_back(dataSet);
//empty filter
terrama2::core::Filter filter;
//accessing data
auto accessor = terrama2::core::DataAccessorFactory::getInstance().make(dataProviderPtr, dataSeriesPtr);
auto remover = std::make_shared<terrama2::core::FileRemover>();
auto uriMap = accessor->getFiles(filter, remover);
auto dataMap = accessor->getSeries(uriMap, filter, remover);
terrama2::core::DcpSeriesPtr dcpSeries = std::make_shared<terrama2::core::DcpSeries>();
dcpSeries->addDcpSeries(dataMap);
assert(dcpSeries->dcpSeriesMap().size() == 1);
QUrl uri;
uri.setScheme("postgis");
uri.setHost("localhost");
uri.setPort(5432);
uri.setUserName("postgres");
uri.setPassword("postgres");
uri.setPath("/terrama2");
//DataProvider information
terrama2::core::DataProvider* dataProviderPostGIS = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPostGISPtr(dataProviderPostGIS);
dataProviderPostGIS->uri = uri.url().toStdString();
dataProviderPostGIS->intent = terrama2::core::DataProviderIntent::PROCESS_INTENT;
dataProviderPostGIS->dataProviderType = "POSTGIS";
dataProviderPostGIS->active = true;
//DataSeries information
terrama2::core::DataSeries* outputDataSeries = new terrama2::core::DataSeries();
terrama2::core::DataSeriesPtr outputDataSeriesPtr(outputDataSeries);
outputDataSeries->semantics = semanticsManager.getSemantics("DCP-postgis");
terrama2::core::DataSetDcp* dataSetOutput = new terrama2::core::DataSetDcp();
terrama2::core::DataSetPtr dataSetOutputPtr(dataSetOutput);
dataSetOutput->active = true;
dataSetOutput->format.emplace("table_name", "dcp_generic");
dataSetOutput->format.emplace("timestamp_column", "datetime");
auto dataStorager = terrama2::core::DataStoragerFactory::getInstance().make(outputDataSeriesPtr, dataProviderPostGISPtr);
for(auto& item : dataMap)
{
dataStorager->store( item.second, dataSetOutputPtr);
}
return 0;
}
const std::string&
FormatWriter::getDimensionOrder() const
{
dimension_size_type series = getSeries();
return metadataRetrieve->getPixelsDimensionOrder(series);
}
dimension_size_type
FormatWriter::getEffectiveSizeC() const
{
dimension_size_type series = getSeries();
return metadataRetrieve->getChannelCount(series);
}
pixel_size_type
FormatWriter::getBitsPerPixel() const
{
dimension_size_type series = getSeries();
return metadataRetrieve->getPixelsSignificantBits(series);
}
ome::xml::model::enums::PixelType
FormatWriter::getPixelType() const
{
dimension_size_type series = getSeries();
return metadataRetrieve->getPixelsType(series);
}
