Пример #1
0
void CanvasRendererWidget::initialize() {
    QProcessorWidget::initialize();

    CanvasRenderer* canvasRenderer = dynamic_cast<CanvasRenderer*>(processor_);
    tgtAssert(canvasRenderer, "CanvasRenderer expected");

    if (!VoreenApplication::app()) {
        LERRORC("voreen.qt.CanvasRendererWidget", "VoreenApplication not instantiated");
        throw new VoreenException("VoreenApplication not instantiated");
    }
    NetworkEvaluator* evaluator = VoreenApplication::app()->getNetworkEvaluator();
    if (!evaluator) {
        LERRORC("voreen.qt.CanvasRendererWidget", "No evaluator assigned to VoreenApplication");
        throw new VoreenException("No evaluator assigned to VoreenApplication");
    }

    canvasWidget_ = new tgt::QtCanvas("", tgt::ivec2(getSize().x, getSize().y), tgt::GLCanvas::RGBADD, this, true, 0);
    canvasWidget_->setMinimumSize(64, 64);
    canvasWidget_->setMouseTracking(true); // for receiving mouse move events without a pressed button

    QGridLayout* layout = new QGridLayout;
    layout->setContentsMargins(0, 0, 0, 0);
    layout->addWidget(canvasWidget_, 0, 0);
    setLayout(layout);

    //show();

    VoreenPainter* painter = new VoreenPainter(canvasWidget_, evaluator, canvasRenderer);
    canvasWidget_->setPainter(painter);
    painter->initialize();

    canvasRenderer->setCanvas(canvasWidget_);
    initialized_ = true;
}
Пример #2
0
VolumeRepresentation* RepresentationConverterLoadFromDiskToGL::convert(const VolumeRepresentation* source) const {
    // convert from disk to ram
    RepresentationConverterLoadFromDisk diskToRam;
    VolumeRepresentation* volumeRam = 0;
    if (diskToRam.canConvert(source))
        volumeRam = diskToRam.convert(source);
    if (!volumeRam) {
        LERRORC("voreen.RepresentationConverterLoadFromDiskToGL", "Failed to create RAM volume from disk volume");
        return 0;
    }

    // convert from ram to disk
    RepresentationConverterUploadGL ramToGL;
    VolumeRepresentation* volumeGL = 0;
    if (ramToGL.canConvert(volumeRam))
        volumeGL = ramToGL.convert(volumeRam);
    if (!volumeGL) {
        LERRORC("voreen.RepresentationConverterLoadFromDiskToGL", "Failed to create GL volume from RAM volume");
    }

    // free volumeRam
    delete volumeRam;
    volumeRam = 0;

    return volumeGL;
}
Пример #3
0
void OpenCLModule::initCL() throw (VoreenException) {
    if (opencl_)
        return;

    opencl_ = new cl::OpenCL();

    const std::vector<cl::Platform>&  platforms = opencl_->getPlatforms();
    if (platforms.empty()) {
        LERRORC("voreen.OpenCLModule", "Found no OpenCL platforms!");
        throw VoreenException("Found no OpenCL platforms");
    }

    const std::vector<cl::Device*>& devices = platforms[0].getDevices();
    if (devices.empty()) {
        LERRORC("voreen.OpenCLModule", "Found no devices in platform!");
        throw VoreenException("Found no devices in platform");
    }
    device_ = devices[0];
    if (glSharing_) {
        LINFO("Using OpenGL sharing");
        context_ = new cl::Context(cl::Context::generateGlSharingProperties(), device_);
    }
    else {
        LINFO("No OpenGL sharing");
        context_ = new cl::Context(device_);
    }
    queue_ = new cl::CommandQueue(context_, device_);
}
Пример #4
0
std::vector<std::pair<std::string, std::string> > Property::getCompatibleEvaluators(const voreen::Property* dst) const{

    std::vector<std::pair<std::string, std::string> > result;

    if (!VoreenApplication::app()) {
        LERRORC("voreen.property", "VoreenApplication not instantiated");
        return result;
    }
    const std::vector<VoreenModule*>& modules = VoreenApplication::app()->getModules();

    for (size_t m=0; m<modules.size(); m++) {
        const std::vector<LinkEvaluatorFactory*>& factories = modules.at(m)->getLinkEvaluatorFactories();
        for (size_t i=0; i<factories.size(); i++) {
            std::vector<std::pair<std::string, std::string> > evaluators = factories.at(i)->getCompatibleLinkEvaluators(this, dst);
            result.insert(result.end(), evaluators.begin(), evaluators.end());
        }
    }

    // put size link evaluator to front (HACK)
    /*for (size_t i=1; i<result.size(); i++) {
        if (result.at(i).first == "LinkEvaluatorRenderSize") {
            std::swap(result.at(0), result.at(i));
            break;
        }
    }*/

    return result;
}
Пример #5
0
PyVoreenQt::PyVoreenQt() {

    if (Py_IsInitialized())
        Py_InitModule("voreenqt", voreenqt_methods);
    else
        LERRORC("voreen.Python.PyVoreenQt", "Python environment not initialized");
}
Пример #6
0
void PlotPickingManager::activateTarget(std::string debugLabel) {
    if (rt_) {
        rt_->activateTarget();
        rt_->setDebugLabel("ID target" + (debugLabel.empty() ? "" : " (" + debugLabel + ")"));
    }
    else
        LERRORC("voreen.plotpickingmanager", "No RenderTarget set!");
}
Пример #7
0
VoreenSettingsDialog::VoreenSettingsDialog(QWidget* parent)
    : QDialog(parent, Qt::Tool | Qt::Window)
{
    setWindowTitle(tr("Voreen settings editor"));

    // vertical layout of the widget
    QVBoxLayout* widgetLayout = new QVBoxLayout();
    setLayout(widgetLayout);

    // layout containing the property widgets
    QGridLayout* propertiesLayout = new QGridLayout();

    // scrollarea surrounding the property widgets
    QWidget* scrollWidget = new QWidget();
    scrollWidget->setLayout(propertiesLayout);
    QScrollArea* scrollArea = new QScrollArea();
    scrollArea->setWidget(scrollWidget);
    scrollArea->setWidgetResizable(true);
    widgetLayout->addWidget(scrollArea);

    std::vector<voreen::Property*> properties = VoreenApplication::app()->getProperties();

    // add property widgets to properties layout
    if (!VoreenApplication::app()) {
        LERRORC("voreen.qt.InputMappingDialog", "VoreenApplication not instantiated");
        return;
    }
    for (size_t i=0; i<properties.size(); ++i) {
        Property* prop = properties.at(i);
        PropertyWidget* propWidget = VoreenApplication::app()->createPropertyWidget(prop);
        if (propWidget) 
            prop->addWidget(propWidget);
        QPropertyWidget* qPropertyWidget = dynamic_cast<QPropertyWidget*>(propWidget);
        if (qPropertyWidget) {
            qPropertyWidget->hideLODControls();
            qPropertyWidget->setMinimumWidth(250);
            CustomLabel* nameLabel = qPropertyWidget->getNameLabel();
            int row = propertiesLayout->rowCount();
            propertiesLayout->addWidget(nameLabel, row, 1);
            propertiesLayout->addWidget(qPropertyWidget, row, 2);
        }
        else {
            LERRORC("voreen.qt.VoreenSettingsDialog", "Unable to create property widget");
        }
    }
}
Пример #8
0
void Font::update(bool reloadFont) {

    if(reloadFont)
    {
        delete font_;
        font_ = 0;

        switch(fontType_) {
        case BitmapFont:
            font_ = new FTBitmapFont(fontName_.c_str()); break;
        case BufferFont:
            font_ = new FTBufferFont(fontName_.c_str()); break;
        case ExtrudeFont:
            font_ = new FTExtrudeFont(fontName_.c_str()); break;
        case OutlineFont:
            font_ = new FTOutlineFont(fontName_.c_str()); break;
        case PixmapFont:
            font_ = new FTPixmapFont(fontName_.c_str()); break;
        case PolygonFont:
            font_ = new FTPolygonFont(fontName_.c_str()); break;
        case TextureFont:
            font_ = new FTTextureFont(fontName_.c_str()); break;
        default:
            LWARNINGC("tgt.Font", "Unknown fontType. Defaulting to TextureFont.");
            font_ = new FTTextureFont(fontName_.c_str());
        }
    }

    if (font_ && !font_->Error()) {
        font_->FaceSize(fontSize_);

        //delete simpleLayout_;
        //simpleLayout_ = 0;
        //simpleLayout_ = new FTSimpleLayout();

        simpleLayout_->SetFont(font_);
        simpleLayout_->SetLineLength(lineWidth_);

        FTGL::TextAlignment hAlign = FTGL::ALIGN_LEFT;
        switch(hAlign_) {
        case Left:
            hAlign = FTGL::ALIGN_LEFT;
            break;
        case Center:
            hAlign = FTGL::ALIGN_CENTER;
            break;
        case Right:
            hAlign = FTGL::ALIGN_RIGHT;
            break;
        }
        simpleLayout_->SetAlignment(hAlign);
    } else {
        delete font_;
        font_ = 0;
        LERRORC("tgt.Font", "Font file could not be loaded: " << fontName_);
    }
}
Пример #9
0
void IDManager::activateTarget(std::string debugLabel) {
    if (rt_) {
        rt_->activateTarget();
        rt_->increaseNumUpdates();
        rt_->setDebugLabel("ID target" + (debugLabel.empty() ? "" : " (" + debugLabel + ")"));
    }
    else
        LERRORC("voreen.idmanager", "No RenderTarget set!");
}
Пример #10
0
PlotBase& PlotBase::operator=(const PlotBase& rhs) {
    // prevent self assignment
    if (this == &rhs)
        return *this;

    std::string* newColumnLabels = 0;
    ColumnType* newColumnTypes = 0;

    // copy array data to new arrays
    // (exception safety: if anything fails the old data is still intact and the object in a valid state)
    try {
        int sum = rhs.keyColumnCount_ + rhs.dataColumnCount_;
        if (sum > 0) {
            newColumnLabels = new std::string[sum];
            newColumnTypes = new ColumnType[sum];
        }
        for (int i=0; i<sum; ++i) {
            newColumnLabels[i] = rhs.columnLabels_[i];
            newColumnTypes[i] = rhs.columnTypes_[i];
        }
    }
    catch (std::bad_alloc&) {
        // nothing has been destroyed yet, current state is valid
        LERRORC("PlotBase::operator=()", "bad_alloc occured, object was not changed!");
        return *this;
    }
    catch (...) {
        // nothing has been destroyed yet, current state is valid
        LERRORC("PlotBase::operator=()", "unknown exception occured, object was not changed!");
        return *this;
    }

    // everything here is exception safe:
    keyColumnCount_ = rhs.keyColumnCount_;
    dataColumnCount_ = rhs.dataColumnCount_;
    // exchange pointers via swap (exception safe) and delete old arrays
    std::swap(columnLabels_, newColumnLabels);
    std::swap(columnTypes_, newColumnTypes);
    delete [] newColumnLabels;
    delete [] newColumnTypes;

    return *this;
}
Пример #11
0
TransFunc* TemplatePropertyTimeline<TransFunc*>::privateGetPropertyAt(float time) {
    TemplatePropertyTimelineState<TransFunc*>* tl = dynamic_cast<TemplatePropertyTimelineState<TransFunc*>* >(timeline_);
    if (tl) {
        TransFunc* func = const_cast<TransFunc*>(tl->getPropertyAt(time));
        return func;
    }
    else {
        LERRORC("TemplatePropertyTimeline<TransFunc*>", "no timeline state");
        return 0;
    }
}
Пример #12
0
VolumeRepresentation* RepresentationConverterLoadFromDisk::convert(const VolumeRepresentation* source) const {
    tgtAssert(source, "null pointer passed");
    const VolumeDisk* volumeDisk = dynamic_cast<const VolumeDisk*>(source);

    if (volumeDisk) {
        try {
            VolumeRAM* volumeRam = volumeDisk->loadVolume();
            return volumeRam;
        }
        catch (tgt::Exception& e) {
            LERRORC("voreen.RepresentationConverterLoadFromDisk", "Unable to create VolumeRAM representation: " + std::string(e.what()));
            return 0;
        }
    }
    else {
        LERRORC("voreen.RepresentationConverterLoadFromDisk", "No VolumeDisk passed");
        return 0;
    }

}
Пример #13
0
PropertyKeyValue<TransFunc*>* PropertyKeyValue<TransFunc*>::clone() const {
    PropertyKeyValue<TransFunc*>* keyvalue = new PropertyKeyValue<TransFunc*>();
    keyvalue->after_ = after_;
    keyvalue->before_ = before_;
    if (value_)
        keyvalue->value_ = value_->clone();
    else
        LERRORC("voreen.PropertyKeyValue<TransFunc>", "No value");
    keyvalue->time_ = time_;
    keyvalue->smooth_ = smooth_;
    return keyvalue;
}
ProcessorWidget* CoreProcessorWidgetFactory::createWidget(Processor* processor) const {
    if (!VoreenApplicationQt::qtApp()) {
        LERRORC("voreen.CoreProcessorWidgetFactory", "VoreenApplicationQt not instantiated");
        return 0;
    }
    QWidget* parent = VoreenApplicationQt::qtApp()->getMainWindow();

    if (dynamic_cast<CanvasRenderer*>(processor))
        return new CanvasRendererWidget(parent, static_cast<CanvasRenderer*>(processor));
    else
        return 0;
}
Пример #15
0
void LinkEvaluatorTransFuncId::eval(Property* src, Property* dst) throw (VoreenException) {
    TransFuncProperty* dstCast = static_cast<TransFuncProperty*>(dst);
    TransFuncProperty* srcCast = static_cast<TransFuncProperty*>(src);

    if(!srcCast->get()) {
        LERRORC("voreen.LinkEvaluatorTransFuncId", "src is has no TF");
        return;
    }

    TransFunc* tf = srcCast->get()->clone();

    dstCast->set(tf);
}
Пример #16
0
VolumeRepresentation* RepresentationConverterUploadGL::convert(const VolumeRepresentation* source) const {
    const Volume* v = dynamic_cast<const Volume*>(source);

    if (!v) {
        //should have checked before...
        //LERROR("Failed to convert!");
        return 0;
    }

    VolumeGL* vgl = 0;
    try {
        vgl = new VolumeGL(v);
        LGL_ERROR;
    }
    catch (VoreenException& e) {
        LERRORC("voreen.RepresentationConverterUploadGL", "Failed to create VolumeGL: " << e.what());
    }
    catch (std::bad_alloc& /*e*/) {
        LERRORC("voreen.RepresentationConverterUploadGL", "Bad allocation during creation of VolumeGL");
    }
    return vgl;
}
ProcessorWidget* OpenCLProcessorWidgetFactory::createWidget(Processor* processor) const {

    if (!VoreenApplicationQt::qtApp()) {
        LERRORC("voreen.openclProcessorWidgetFactory", "VoreenApplicationQt not instantiated");
        return 0;
    }
    QWidget* parent = VoreenApplicationQt::qtApp()->getMainWindow();

    if (dynamic_cast<DynamicCLProcessor*>(processor))
        return new DynamicOpenCLWidget(parent, static_cast<DynamicCLProcessor*>(processor));

    return 0;
}
void TemplatePropertyTimeline<Camera>::deserialize(XmlDeserializer& s) {
    s.deserialize("activeOnRendering", activeOnRendering_);
    PropertyOwner* propertyOwner = 0;
    s.deserialize("propertyOwner", propertyOwner);
    std::string propertyId;
    s.deserialize("propertyId", propertyId);
    if (propertyOwner)
        property_ = dynamic_cast<CameraProperty*>(propertyOwner->getProperty(propertyId));
    else
        LERRORC("TemplatePropertyTimeline<Camera>", "deserialize(): no property owner");
    s.deserialize("duration", duration_);
    s.deserialize("timeline", timeline_);
}
ImageMappingInformation::ImageMappingInformation(const cgt::vec3& size, const cgt::vec3& offset, const cgt::vec3& voxelSize, const cgt::mat4& customTransformation /*= LinearMapping<float>::identity*/)
    : _size(size)
    , _offset(offset)
    , _voxelSize(voxelSize)
    , _customTransformation(customTransformation)
{
    cgt::mat4 invTrafo;
    if (! _customTransformation.invert(invTrafo)) {
        LERRORC("CAMPVis.core.ImageMappingInformation", "Custom transformation is not invertable! Resetting to identity tranformation.");
        _customTransformation = cgt::mat4::identity;
    }

    updateMatrices();
}
Пример #20
0
col4 IDManager::getColorFromId(int id) {
    if(id < 0)
        return col4(0,0,0,0);

    if(id > 16777216) {
        LERRORC("voreen.IDManager", "id to big!");
        return col4(0,0,0,0);
    }

    col4 c;
    c.b = id & 255;
    c.g = (id >> 8) & 255;
    c.r = (id >> 16) & 255;
    c.a = 255;
    return c;
}
Пример #21
0
std::string OpenCLProperty::getProgramAsString(std::string filename) {
    //std::string completeFilename = ShdrMgr.completePath(filename);
    tgt::File* file = FileSys.open(filename);

    // check if file is open
    if (!file || !file->isOpen()) {
        LERRORC("voreen.openclproperty", "File not found: " << filename);
        delete file;
        return "";
    }

    std::string s = file->getAsString();

    file->close();
    delete file;
    return s;
}
Пример #22
0
void IDManager::increaseID() {
    if (currentID_.b == 255) {
        currentID_.b = 0;
        if (currentID_.g == 255) {
            currentID_.g = 0;
            if (currentID_.r == 255) {
                LERRORC("voreen.idmanager", "Out of ids...");
            }
            else
                currentID_.r++;

        }
        else
            currentID_.g++;
    }
    else
        currentID_.b++;
}
Пример #23
0
bool Property::isLinkableWith(const voreen::Property* dst) const{

    if (!VoreenApplication::app()) {
        LERRORC("voreen.property", "VoreenApplication not instantiated");
        return false;
    }
    const std::vector<voreen::VoreenModule*>& modules = VoreenApplication::app()->getModules();

    for (size_t m=0; m<modules.size(); m++) {
        const std::vector<LinkEvaluatorFactory*>& factories = modules.at(m)->getLinkEvaluatorFactories();
        for (size_t i=0; i<factories.size(); i++) {
            if (factories.at(i)->arePropertiesLinkable(this, dst))
                return true;
        }
    }

    return false;
}
ProcessorWidget* PlotProcessorWidgetFactory::createWidget(Processor* processor) const {

    if (!VoreenApplicationQt::qtApp()) {
        LERRORC("voreen.plotting.PlotProcessorWidgetFactory", "VoreenApplicationQt not instantiated");
        return 0;
    }
    QWidget* parent = VoreenApplicationQt::qtApp()->getMainWindow();

    if (dynamic_cast<PlotDataSelect*>(processor))
       return new PlotDataSelectWidget(parent, static_cast<PlotDataSelect*>(processor));
    else if (dynamic_cast<PlotDataGroup*>(processor))
       return new PlotDataGroupWidget(parent, static_cast<PlotDataGroup*>(processor));
    else if (dynamic_cast<PlotDataFitFunction*>(processor))
       return new PlotDataFitFunctionWidget(parent, static_cast<PlotDataFitFunction*>(processor));
    else if (dynamic_cast<PlotDataMerge*>(processor))
       return new PlotDataMergeWidget(parent, static_cast<PlotDataMerge*>(processor));


    return 0;
}
Пример #25
0
void AnimationExportWidget::renderingStep(){
    if (animation_ == 0)
        return;
    tgtAssert(canvas_, "No canvas");

    if (currentFrame_ > duration_ / fpsFactor_){
        endRendering();
    }
    else {
        animation_->renderAt((float)currentFrame_*fpsFactor_/ fps_);
        #ifdef VRN_WITH_FFMPEG
        if ((renderState_== Recording) &&(painter_->getCanvasRenderer())) {
            if (canvas_->getSize() != tgt::ivec2(spinWidth_->value(), spinHeight_->value())) {
                canvas_->resize(spinWidth_->value(), spinHeight_->value());
                canvas_->repaint();
            }

            tgt::Texture* texture = painter_->getCanvasRenderer()->getImageColorTexture();
            if (texture && texture->getDimensions().xy() == tgt::ivec2(spinWidth_->value(), spinHeight_->value())) {
                texture->downloadTexture();
                ffmpegEncoder_.nextFrame(texture->getPixelData());
            }
            else {
                LERRORC("voreenqt.AnimationExportWidget",
                        "Frame texture could not be downloaded or dimensions do not match");
            }
        } else {
        #endif
            // render frame to file
            char fn[1024];
            sprintf(fn, "%s%05d%s", std::string(recordPathName_ + "/frame").c_str(), currentFrame_, ".png");
            try {
                painter_->renderToSnapshot(fn, tgt::ivec2(spinWidth_->value(), spinHeight_->value()));
            } catch (...) {}
        #ifdef VRN_WITH_FFMPEG
        }
        #endif
        ++currentFrame_;
    }
}
Пример #26
0
void LinkEvaluatorCameraLookId::eval(Property* src, Property* dst) throw (VoreenException) {
    bool camToProp = true;
    CameraProperty* camProp = dynamic_cast<CameraProperty*>(src);
    FloatVec3Property* vecProp = dynamic_cast<FloatVec3Property*>(dst);
    if(!camProp) {
        camToProp = false;
        camProp = dynamic_cast<CameraProperty*>(dst);
        vecProp = dynamic_cast<FloatVec3Property*>(src);
    }

    tgt::Camera cam = camProp->get();
    if(camToProp)
        vecProp->set(cam.getLook());
    else {
        if(length(vecProp->get()) == 0.f) {
            LERRORC("voreen.LinkEvaluatorCameraLookId", "Can not use 0 vector to set look vector of camera");
            return;
        }
        cam.setFocus(cam.getPosition() + cam.getFocalLength() * normalize(vecProp->get()));
        camProp->set(cam);
    }
}
Пример #27
0
void TemplatePropertyTimeline<TransFunc*>::setProperty(Property* p) {
    TemplateProperty<TransFunc*>* tp = dynamic_cast<TemplateProperty<TransFunc*>*>(p);
    if(tp) {
        property_ = tp;
        if(timeline_->getKeyValues().size() == 0) {
            delete timeline_;
            timeline_ = 0;

            TransFunc* func = property_->get();
            if (func)
                func = func->clone();
            else {
                LWARNINGC("", "warn 2");
                func = new TransFunc1DKeys();
                property_->set(func->clone());
            }
            timeline_ = new TransFuncPropertyTimelineState(new PropertyKeyValue<TransFunc*>(func,0));
        }
    }
    else {
        LERRORC("voreen.TemplatePropertyTimeline", "Property type mismatch!");
    }
}
Пример #28
0
VolumeHistogramIntensityGradient::VolumeHistogramIntensityGradient(const VolumeBase* volumeHandleGrad, const VolumeBase* volumeHandleIntensity,
                                                       int bucketCounti, int bucketCountg, bool scale)
    : scaleFactor_(1.f)
{
    const VolumeRAM* volumeGrad = volumeHandleGrad->getRepresentation<VolumeRAM>();
    const VolumeRAM* volumeIntensity = volumeHandleIntensity->getRepresentation<VolumeRAM>();

    if (dynamic_cast<const VolumeRAM_3xUInt8*>(volumeGrad)) {
        calcHG(static_cast<const VolumeRAM_3xUInt8*>(volumeGrad), volumeIntensity, bucketCounti, bucketCountg, scale);
    }
    else if (dynamic_cast<const VolumeRAM_4xUInt8*>(volumeGrad)) {
        calcHG(static_cast<const VolumeRAM_4xUInt8*>(volumeGrad), volumeIntensity, bucketCounti, bucketCountg, scale);
    }
    else if (dynamic_cast<const VolumeRAM_3xUInt16*>(volumeGrad)) {
        calcHG(static_cast<const VolumeRAM_3xUInt16*>(volumeGrad), volumeIntensity, bucketCounti, bucketCountg, scale);
    }
    else if (dynamic_cast<const VolumeRAM_4xUInt16*>(volumeGrad)) {
        calcHG(static_cast<const VolumeRAM_4xUInt16*>(volumeGrad), volumeIntensity, bucketCounti, bucketCountg, scale);
    }
    else {
        LERRORC("voreen.VolumeVolumeHistogramIntensityGradient",
                "VolumeVolumeHistogramIntensityGradient needs 24 or 32 bit DS as input!");
    }
}
Пример #29
0
void IDManager::deactivateTarget() {
    if (rt_)
        rt_->deactivateTarget();
    else
        LERRORC("voreen.idmanager", "No RenderTarget set!");
}
Пример #30
0
cl::Device* OpenCLModule::getCLDevice() const {
    if (!device_)
        LERRORC("voreen.OpenCLModule", "No OpenCL device. Call initCL first!");
    return device_;
}