void BaseOp::stagePostFinished()
{
if (isAborted() || m_reply == NULL) {
DBGLOG(LOG_DEBUG, 10, QString::fromUtf8("Aborted at 'post' stage"));
return report(WTFStatus_Aborted);
}
if (m_reply->error() != QNetworkReply::NoError) {
DBGLOG(LOG_ERROR, 2, QString::fromUtf8("Network error, code=%1").arg(m_reply->error()));
setProperty("varNetworkError", m_reply->error());
m_reply->deleteLater();
m_reply = NULL;
return report(WTFStatus_NetworkError);
}
QByteArray responseData = m_reply->readAll();
m_reply->deleteLater();
m_reply = NULL;
DBGLOG(LOG_DEBUG, 10, QString::fromUtf8("response data: %1").arg(QString::fromUtf8(responseData)));
QVariantMap result;
if (!parseResultXml(responseData, result)) {
DBGLOG(LOG_DEBUG, 2, QString::fromUtf8("parseResultXml failed!"));
result.clear();
}
report(processImpl(responseData, result));
}
void TypeAndConstantInference::process(ASTPtr & ast, const Context & context,
CollectAliases & aliases,
const AnalyzeColumns & columns,
const AnalyzeLambdas & lambdas,
ExecuteTableFunctions & table_functions)
{
processImpl(ast, context, aliases, columns, info, lambdas, table_functions);
}
static void processImpl(const ASTPtr & ast, CollectAliases::Aliases & aliases, CollectAliases::Kind kind, size_t keep_kind_for_depth)
{
String alias = ast->tryGetAlias();
if (!alias.empty())
{
auto it_inserted = aliases.emplace(alias, CollectAliases::AliasInfo(ast, kind));
if (!it_inserted.second && ast->getTreeHash() != it_inserted.first->second.node->getTreeHash())
{
std::stringstream message;
message << "Different expressions with the same alias " << backQuoteIfNeed(alias) << ":\n";
formatAST(*it_inserted.first->second.node, message, 0, false, true);
message << "\nand\n";
formatAST(*ast, message, 0, false, true);
message << "\n";
throw Exception(message.str(), ErrorCodes::MULTIPLE_EXPRESSIONS_FOR_ALIAS);
}
}
for (auto & child : ast->children)
{
if (typeid_cast<const ASTSelectQuery *>(child.get()))
{
/// Don't go into subqueries.
}
else if (typeid_cast<const ASTTableExpression *>(child.get()))
{
processImpl(child, aliases, CollectAliases::Kind::Table, 1);
}
else if (typeid_cast<const ASTArrayJoin *>(child.get()))
{
/// ASTArrayJoin -> ASTExpressionList -> element of expression AS alias
processImpl(child, aliases, CollectAliases::Kind::ArrayJoin, 3);
}
else if (keep_kind_for_depth > 0)
{
processImpl(child, aliases, kind, keep_kind_for_depth - 1);
}
else
{
processImpl(child, aliases, CollectAliases::Kind::Expression, 0);
}
}
}
void
pcl::modeler::AbstractWorker::process()
{
for (auto &cloud_mesh_item : cloud_mesh_items_)
{
processImpl(cloud_mesh_item);
}
emit finished();
return;
}
void AnalyzeColumns::process(ASTPtr & ast, const CollectAliases & aliases, const CollectTables & tables)
{
/// If this is SELECT query, don't go into FORMAT and SETTINGS clauses
/// - they contain identifiers that are not columns.
const ASTSelectQuery * select = typeid_cast<const ASTSelectQuery *>(ast.get());
for (auto & child : ast->children)
{
if (select && (child.get() == select->format.get() || child.get() == select->settings.get()))
continue;
processImpl(child, columns, aliases, tables);
}
}
void
pcl::modeler::AbstractWorker::process()
{
for (QList<CloudMeshItem*>::iterator cloud_mesh_items_it = cloud_mesh_items_.begin();
cloud_mesh_items_it != cloud_mesh_items_.end();
++ cloud_mesh_items_it)
{
processImpl(*cloud_mesh_items_it);
}
emit finished();
return;
}
void
pcl::modeler::AbstractWorker::process()
{
while (!cloud_actors_.empty())
{
sensor_msgs::PointCloud2::Ptr cloud(new sensor_msgs::PointCloud2);
processImpl(cloud_actors_.back()->getCloud(), cloud);
cloud_actors_.back()->updateCloud(cloud);
cloud_actors_.pop_back();
}
emit finished();
return;
}
TyErrorId EngineBase::process(CAS& cas, ResultSpecification const& resultSpec) {
try {
util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE);
if (!checkAndSetCallingSequenceProcess()) {
return logError(clTrace, UIMA_ERR_ENGINE_INVALID_CALLING_SEQUENCE);
}
// (ee) WHY DO THIS CHECK???
//checkCASCompatibility(cas);
// Removed code that used to skip the processing if the document
// was empty, since not all Sofas have local text. (bll)
return processImpl(cas, resultSpec);
} catch (Exception& rclException) {
getAnnotatorContext().getLogger().logError(rclException.getErrorInfo());
//return rclException.getErrorInfo().getErrorId();
UIMA_EXC_RETHROW(rclException, NULL);
}
}
void CollectAliases::process(const ASTPtr & ast)
{
processImpl(ast, aliases, Kind::Expression, 0);
}
void AnalyzeLambdas::process(ASTPtr & ast)
{
LambdaScopes lambda_scopes;
for (auto & child : ast->children)
processImpl(child, lambda_scopes, nullptr, higher_order_functions);
}
/**
* \brief Form a quantized image pyramid from a source image.
*
* \param[in] src The source image. Type depends on the modality.
* \param[in] mask Optional mask. If not empty, unmasked pixels are set to zero
* in quantized image and cannot be extracted as features.
*/
Ptr<QuantizedPyramid> process(const Mat& src,
const Mat& mask = Mat()) const
{
return processImpl(src, mask);
}
unsigned Connection::threadProc( void *param ) {
while( !shouldExit(10) ) {
processImpl();
}
return 0;
}
void RaycastingProcessor::updateResult(DataContainer& data) {
ImageRepresentationGL::ScopedRepresentation img(data, p_sourceImageID.getValue());
ScopedTypedData<RenderData> entryPoints(data, p_entryImageID.getValue());
ScopedTypedData<RenderData> exitPoints(data, p_exitImageID.getValue());
ScopedTypedData<CameraData> camera(data, p_camera.getValue());
if (img != nullptr && entryPoints != nullptr && exitPoints != nullptr && camera != nullptr) {
if (img->getDimensionality() == 3) {
// little hack to support LOD texture lookup for the gradients:
// if texture does not yet have mipmaps, create them.
const cgt::Texture* tex = img->getTexture();
if (tex->getFilter() != cgt::Texture::MIPMAP) {
const_cast<cgt::Texture*>(tex)->setFilter(cgt::Texture::MIPMAP);
glGenerateMipmap(GL_TEXTURE_3D);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
LGL_ERROR;
}
_shader->activate();
_shader->setIgnoreUniformLocationError(true);
// Compute min/max depth if needed by shader
if (_shader->getUniformLocation("_minDepth") != -1) {
_shader->deactivate();
float minDepth = _minReduction->reduce(entryPoints->getDepthTexture()).front();
_shader->activate();
_shader->setUniform("_minDepth", minDepth);
}
if (_shader->getUniformLocation("_maxDepth") != -1) {
_shader->deactivate();
float maxDepth = _maxReduction->reduce(exitPoints->getDepthTexture()).front();
_shader->activate();
_shader->setUniform("_maxDepth", maxDepth);
}
decorateRenderProlog(data, _shader);
_shader->setUniform("_viewportSizeRCP", 1.f / cgt::vec2(getEffectiveViewportSize()));
_shader->setUniform("_jitterStepSizeMultiplier", p_jitterStepSizeMultiplier.getValue());
// compute sampling step size relative to volume size
float samplingStepSize = 1.f / (p_samplingRate.getValue() * cgt::max(img->getSize()));
_shader->setUniform("_samplingStepSize", samplingStepSize);
// compute and set camera parameters
const cgt::Camera& cam = camera->getCamera();
float n = cam.getNearDist();
float f = cam.getFarDist();
_shader->setUniform("_cameraPosition", cam.getPosition());
_shader->setUniform("const_to_z_e_1", 0.5f + 0.5f*((f+n)/(f-n)));
_shader->setUniform("const_to_z_e_2", ((f-n)/(f*n)));
_shader->setUniform("const_to_z_w_1", ((f*n)/(f-n)));
_shader->setUniform("const_to_z_w_2", 0.5f*((f+n)/(f-n))+0.5f);
_shader->setIgnoreUniformLocationError(false);
// bind input textures
cgt::TextureUnit volumeUnit, entryUnit, exitUnit, tfUnit;
img->bind(_shader, volumeUnit, "_volume", "_volumeTextureParams");
p_transferFunction.getTF()->bind(_shader, tfUnit);
if (! _bindEntryExitDepthTextures) {
entryPoints->bindColorTexture(_shader, entryUnit, "_entryPoints", "_entryParams");
exitPoints->bindColorTexture(_shader, exitUnit, "_exitPoints", "_exitParams");
processImpl(data, img);
}
else {
cgt::TextureUnit entryUnitDepth, exitUnitDepth;
entryPoints->bind(_shader, entryUnit, entryUnitDepth, "_entryPoints", "_entryPointsDepth", "_entryParams");
exitPoints->bind(_shader, exitUnit, exitUnitDepth, "_exitPoints", "_exitPointsDepth", "_exitParams");
processImpl(data, img);
}
decorateRenderEpilog(_shader);
_shader->deactivate();
cgt::TextureUnit::setZeroUnit();
LGL_ERROR;
}
else {
LERROR("Input image must have dimensionality of 3.");
}
}
else {
LDEBUG("No suitable input image found.");
}
}
