void VolumeHandlePropertyWidget::volumeAdded(const VolumeCollection* /*source*/, const VolumeHandle* /*handle*/) {
    int i = volumeContainer_->size()-1;
    VolumeHandle* handle = volumeContainer_->at(i);
    volumeSelectorBox_->addItem(VolumeViewHelper::generateBorderedPreview(handle->getVolume(), 30, 1),
        QString::fromStdString(VolumeViewHelper::getStrippedVolumeName(handle)),
        QString::fromStdString(VolumeViewHelper::getVolumeName(handle)));

    // disable selector box, when no volume available
    volumeSelectorBox_->setEnabled(volumeSelectorBox_->count() > 1);

    emit modified();
}
void VolumeHandlePropertyWidget::updateFromContainer() {

    if (!volumeContainer_)
        return;

    volumeSelectorBox_->clear();
    QPixmap white = QPixmap(30, 30);
    white.fill();
    volumeSelectorBox_->addItem(white, tr("Select volume ..."));
    for (size_t i = 0; i < volumeContainer_->size(); i++) {
        VolumeHandle* handle = volumeContainer_->at(i);
        volumeSelectorBox_->addItem(VolumeViewHelper::generateBorderedPreview(handle->getVolume(), 30, 1),
            QString::fromStdString(VolumeViewHelper::getStrippedVolumeName(handle)),
            QString::fromStdString(VolumeViewHelper::getVolumeName(handle)));
    }

    // disable selector box, when no volume available
    volumeSelectorBox_->setEnabled(volumeSelectorBox_->count() > 1);
}
void CoordinateTransformation::process() {

    // do nothing, if neither input data nor coordinate system selection has changed
    if (!geometryInport_.hasChanged() && !volumeInport_.hasChanged() && !forceUpdate_)
        return;

    // clear output
    delete geometryOutport_.getData();
    geometryOutport_.setData(0);
    forceUpdate_ = false;

    // return if no input data present
    if (!geometryInport_.hasData() || !volumeInport_.hasData())
        return;

    // retrieve and check geometry from inport
    PointListGeometryVec3* geometrySrc = dynamic_cast<PointListGeometryVec3*>(geometryInport_.getData());
    PointSegmentListGeometryVec3* geometrySegmentSrc = dynamic_cast<PointSegmentListGeometryVec3*>(geometryInport_.getData());
    if (!geometrySrc && !geometrySegmentSrc) {
        LWARNING("Geometry of type TGTvec3PointListGeometry or TGTvec3PointSegmentListGeometry expected");
        return;
    }

    // retrieve volume handle from inport
    VolumeHandle* volumeHandle = volumeInport_.getData();
    tgtAssert(volumeHandle, "No volume handle");
    tgtAssert(volumeHandle->getVolume(), "No volume");

    // create output geometry object
    PointListGeometryVec3* geometryConv = 0;
    PointSegmentListGeometryVec3* geometrySegmentConv = 0;
    if (geometrySrc)
        geometryConv = new PointListGeometryVec3();
    else if (geometrySegmentSrc)
        geometrySegmentConv = new PointSegmentListGeometryVec3();

    //
    // convert points
    //

    // voxel coordinates (no transformation necessary)
    if (targetCoordinateSystem_.isSelected("voxel-coordinates")) {
        // pointlist
        if (geometrySrc) {
            std::vector<tgt::vec3> geomPointsConv = std::vector<tgt::vec3>(geometrySrc->getData());
            geometryConv->setData(geomPointsConv);
        }
        // segmentlist
        else if (geometrySegmentSrc) {
            std::vector< std::vector<tgt::vec3> >geomPointsConv = std::vector< std::vector<tgt::vec3> >(geometrySegmentSrc->getData());
            geometrySegmentConv->setData(geomPointsConv);
        }
    }
    // volume coordinates
    else if (targetCoordinateSystem_.isSelected("volume-coordinates")) {
        tgt::vec3 dims(volumeHandle->getVolume()->getDimensions());
        tgt::vec3 cubeSize = volumeHandle->getVolume()->getCubeSize();
        // pointlist
        if (geometrySrc) {
            std::vector<tgt::vec3> geomPointsConv = std::vector<tgt::vec3>(geometrySrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); i++)
                geomPointsConv[i] = ((geomPointsConv[i]/dims) - 0.5f) * cubeSize;
            geometryConv->setData(geomPointsConv);
        }
        // segmentlist
        else if (geometrySegmentSrc) {
            std::vector< std::vector<tgt::vec3> >geomPointsConv = std::vector< std::vector<tgt::vec3> >(geometrySegmentSrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); ++i) {
                for (size_t j=0; j<geomPointsConv[i].size(); ++j) {
                    geomPointsConv[i][j] = ((geomPointsConv[i][j]/dims) - 0.5f) * cubeSize;
                }
                geometrySegmentConv->addSegment(geomPointsConv[i]);
            }
        }
    }
    // world coordinates
    else if (targetCoordinateSystem_.isSelected("world-coordinates")) {
        tgt::mat4 voxelToWorldTrafo = volumeHandle->getVolume()->getVoxelToWorldMatrix();
        // pointlist
        if (geometrySrc) {
            std::vector<tgt::vec3> geomPointsConv = std::vector<tgt::vec3>(geometrySrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); i++)
                geomPointsConv[i] = voxelToWorldTrafo * geomPointsConv[i];
            geometryConv->setData(geomPointsConv);
        }
        // segmentlist
        else if (geometrySegmentSrc) {
            std::vector< std::vector<tgt::vec3> >geomPointsConv = std::vector< std::vector<tgt::vec3> >(geometrySegmentSrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); ++i) {
                for (size_t j=0; j<geomPointsConv[i].size(); ++j) {
                    geomPointsConv[i][j] = voxelToWorldTrafo * geomPointsConv[i][j];
                }
                geometrySegmentConv->addSegment(geomPointsConv[i]);
            }
        }
    }
    // texture coordinates: [0:1.0]^3
    else if (targetCoordinateSystem_.isSelected("texture-coordinates")) {
        tgt::vec3 dims(volumeHandle->getVolume()->getDimensions());
        // pointlist
        if (geometrySrc) {
            std::vector<tgt::vec3> geomPointsConv = std::vector<tgt::vec3>(geometrySrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); i++)
                geomPointsConv[i] /= dims;
            geometryConv->setData(geomPointsConv);
        }
        // segmentlist
        else if (geometrySegmentSrc) {
            std::vector< std::vector<tgt::vec3> >geomPointsConv = std::vector< std::vector<tgt::vec3> >(geometrySegmentSrc->getData());
            for (size_t i=0; i<geomPointsConv.size(); ++i) {
                for (size_t j=0; j<geomPointsConv[i].size(); ++j) {
                    geomPointsConv[i][j] /= dims;
                }
                geometrySegmentConv->addSegment(geomPointsConv[i]);
            }
        }
    }

    // assign result to outport
    if (geometrySrc)
        geometryOutport_.setData(geometryConv);
    else if (geometrySegmentSrc)
        geometryOutport_.setData(geometrySegmentConv);
    else {
        LWARNING("No geometry object created");
    }
}
void VolumeHandlePropertyWidget::updateFromProperty() {
    VolumeHandle* handle = getVolume();
    if (handle) {
        dimensionLabel_->show();
        pathLabel_->show();
        spacingLabel_->show();
        memSizeLabel_->show();
        previewLabel_->show();

        std::string name = VolumeViewHelper::getStrippedVolumeName(handle);
        std::string path = VolumeViewHelper::getVolumePath(handle);
        if(name.size() > 30) {
            volumeNameLabel_->setToolTip(QString::fromStdString(name));
            int end = name.size();
            std::string startString;
            std::string endString;
            for(size_t i = 0; i < 14; i++){
                 startString += name.at(i);
                 endString += name.at(end-14+i);
            }
            name = startString+"..."+endString;
        }
        if (path.size() > 30) {
            pathLabel_->setToolTip(QString::fromStdString(path));
            int end = path.size();
            std::string startString;
            std::string endString;
            for(size_t i = 0; i < 14; i++){
                 startString += path.at(i);
                 endString += path.at(end-14+i);
            }
            path = startString+"..."+endString;
        }

        volumeNameLabel_->setText(QString::fromStdString(" " + name+ " ("+ VolumeViewHelper::getVolumeType(handle->getVolume())+") "));
        pathLabel_->setText(QString::fromStdString(" "+path));
        dimensionLabel_->setText(QString::fromStdString(VolumeViewHelper::getVolumeDimension(handle->getVolume())));
        spacingLabel_->setText(QString::fromStdString(VolumeViewHelper::getVolumeSpacing(handle->getVolume())));
        memSizeLabel_->setText(QString::fromStdString(VolumeViewHelper::getVolumeMemorySize(handle->getVolume())));
        previewLabel_->setPixmap(VolumeViewHelper::generateBorderedPreview(handle->getVolume(), 70, 0));

        // adjust selected index of volume selector box to currently assigned volume
        volumeSelectorBox_->setCurrentIndex(0);
        if (volumeContainer_) {
            tgtAssert(volumeContainer_->size()+1 == static_cast<size_t>(volumeSelectorBox_->count()),
                "Sizes of volume container and volume selector box do not match");
            for (size_t i=0; i < volumeContainer_->size(); ++i) {
                if (handle == volumeContainer_->at(i)) {
                    volumeSelectorBox_->setCurrentIndex(i+1);
                    break;
                }

            }
        }

    }
    else {
        volumeNameLabel_->setText(tr(" no volume"));
        volumeNameLabel_->adjustSize();
        pathLabel_->hide();
        previewLabel_->setPixmap(QPixmap());
        dimensionLabel_->hide();
        spacingLabel_->hide();
        memSizeLabel_->hide();
        previewLabel_->hide();
    }
}