MultichannelRaycaster::MultichannelRaycaster()
: Processor()
, shader_("multichannelraycaster.frag", false)
, volumePort_("volume")
, entryPort_("entry")
, exitPort_("exit")
, outport_("outport")
, transferFunctions_("transfer-functions", "Transfer functions")
, raycasting_("raycaster", "Raycasting")
, camera_("camera", "Camera")
, lighting_("lighting", "Lighting", &camera_)
, positionIndicator_("positionindicator", "Position Indicator") {
transferFunctions_.addProperty(new TransferFunctionProperty(
"transferFunction1", "Channel 1", TransferFunction(), &volumePort_), false);
transferFunctions_.addProperty(new TransferFunctionProperty(
"transferFunction2", "Channel 2", TransferFunction(), &volumePort_), false);
transferFunctions_.addProperty(new TransferFunctionProperty(
"transferFunction3", "Channel 3", TransferFunction(), &volumePort_), false);
transferFunctions_.addProperty(new TransferFunctionProperty(
"transferFunction4", "Channel 4", TransferFunction(), &volumePort_), false);
shader_.onReload([this]() { invalidate(InvalidationLevel::InvalidResources); });
addPort(volumePort_, "VolumePortGroup");
addPort(entryPort_, "ImagePortGroup1");
addPort(exitPort_, "ImagePortGroup1");
addPort(outport_, "ImagePortGroup1");
addProperty(raycasting_);
addProperty(camera_);
addProperty(lighting_);
addProperty(positionIndicator_);
addProperty(transferFunctions_);
volumePort_.onChange(this, &MultichannelRaycaster::initializeResources);
}
LightVolumeGL::LightVolumeGL()
: Processor()
, inport_("inport")
, outport_("outport")
, lightSource_("lightSource")
, supportColoredLight_("supportColoredLight", "Support Light Color", false)
, volumeSizeOption_("volumeSizeOption", "Light Volume Size")
, transferFunction_("transferFunction", "Transfer function", TransferFunction(), &inport_)
, floatPrecision_("floatPrecision", "Float Precision", false)
, propagationShader_("lighting/lightpropagation.vert", "lighting/lightpropagation.geom",
"lighting/lightpropagation.frag", true)
, mergeShader_("lighting/lightvolumeblend.vert", "lighting/lightvolumeblend.geom",
"lighting/lightvolumeblend.frag", true)
, mergeFBO_(nullptr)
, internalVolumesInvalid_(false)
, volumeDimOut_(0)
, lightDir_(0.f)
, lightPos_(0.f)
, lightColor_(1.f)
, calculatedOnes_(false) {
addPort(inport_);
addPort(outport_);
addPort(lightSource_);
supportColoredLight_.onChange(this, &LightVolumeGL::supportColoredLightChanged);
addProperty(supportColoredLight_);
volumeSizeOption_.addOption("1", "Full of incoming volume", 1);
volumeSizeOption_.addOption("1/2", "Half of incoming volume", 2);
volumeSizeOption_.addOption("1/4", "Quarter of incoming volume", 4);
volumeSizeOption_.setSelectedIndex(1);
volumeSizeOption_.setCurrentStateAsDefault();
volumeSizeOption_.onChange(this, &LightVolumeGL::volumeSizeOptionChanged);
addProperty(volumeSizeOption_);
addProperty(transferFunction_);
floatPrecision_.onChange(this, &LightVolumeGL::floatPrecisionChanged);
addProperty(floatPrecision_);
propagationShader_.onReload([this]() { invalidate(InvalidationLevel::InvalidResources); });
mergeShader_.onReload([this]() { invalidate(InvalidationLevel::InvalidResources); });
}
LightingRaycaster::LightingRaycaster()
: Processor()
, shader_("lighting/lightingraycasting.frag", false)
, volumePort_("volume")
, entryPort_("entry-points")
, exitPort_("exit-points")
, lightVolumePort_("lightVolume")
, outport_("outport")
, enableLightColor_("supportColoredLight", "Enable Light Color", false,
InvalidationLevel::InvalidResources)
, transferFunction_("transferFunction", "Transfer function", TransferFunction(), &volumePort_)
, channel_("channel", "Render Channel")
, raycasting_("raycaster", "Raycasting")
, camera_("camera", "Camera")
, lighting_("lighting", "Lighting") {
shader_.onReload([this]() { invalidate(InvalidationLevel::InvalidResources); });
addPort(volumePort_);
addPort(entryPort_, "ImagePortGroup1");
addPort(exitPort_, "ImagePortGroup1");
addPort(lightVolumePort_);
addPort(outport_, "ImagePortGroup1");
channel_.addOption("Channel 1", "Channel 1", 0);
channel_.setCurrentStateAsDefault();
volumePort_.onChange(this, &LightingRaycaster::onVolumeChange);
addProperty(raycasting_);
addProperty(camera_);
lighting_.addProperty(enableLightColor_);
addProperty(lighting_);
addProperty(channel_);
addProperty(transferFunction_);
}
VolumeRaycaster::VolumeRaycaster()
: Processor()
, shader_("raycasting.frag", false)
, volumePort_("volume")
, entryPort_("entry")
, exitPort_("exit")
, outport_("outport")
, transferFunction_("transferFunction", "Transfer function", TransferFunction(), &volumePort_)
, channel_("channel", "Render Channel")
, raycasting_("raycaster", "Raycasting")
, camera_("camera", "Camera")
, lighting_("lighting", "Lighting", &camera_)
, positionIndicator_("positionindicator", "Position Indicator")
, toggleShading_("toggleShading", "Toggle Shading", new KeyboardEvent('L'),
new Action(this, &VolumeRaycaster::toggleShading)) {
shader_.onReload([this]() { invalidate(INVALID_RESOURCES); });
addPort(volumePort_, "VolumePortGroup");
addPort(entryPort_, "ImagePortGroup1");
addPort(exitPort_, "ImagePortGroup1");
addPort(outport_, "ImagePortGroup1");
channel_.addOption("Channel 1", "Channel 1", 0);
channel_.setCurrentStateAsDefault();
volumePort_.onChange(this, &VolumeRaycaster::onVolumeChange);
addProperty(channel_);
addProperty(transferFunction_);
addProperty(raycasting_);
addProperty(camera_);
addProperty(lighting_);
addProperty(positionIndicator_);
addProperty(toggleShading_);
}
bool ObjectContainer::verifyData(QJsonObject& object)
{
// Verify mandatory keys for all types (name, type):
auto nameIt = object.find("name");
if (nameIt == object.end())
{
StaticLogger::logit("WARNING: Found no name for object in project file!");
return false;
}
const QString& name = nameIt->toString();
// Check if "type" key exists:
auto typeIt = object.find("type");
if (typeIt == object.end())
{
StaticLogger::logit("WARNING: Found no type for object '" + name + "' in project file!");
return false;
}
ObjectType type = stringToObjectType(typeIt->toString().toStdString());
// Insert all non-existent keys for all types with default values,
if (!object.contains("id"))
{
object.insert("id", s_id);
m_ids.insert(s_id++);
}
if (!object.contains("enabled"))
object["enabled"] = true;
if (type == ObjectType::Mesh)
{
// Verify mandatory keys for meshes
if (!object.contains("obj-file"))
{
StaticLogger::logit("WARNING: Found no obj-file for Mesh '" + name + "' in project file!");
return false;
}
// Insert all non-existent keys for meshes with default values
if (!object.contains("position"))
object["position"] = QJsonObject{ { "x", 0.0 }, { "y", 0.0 }, { "z", 0.0 } };
if (!object.contains("scaling"))
object["scaling"] = QJsonObject{ { "x", 1.0 }, { "y", 1.0 }, { "z", 1.0 } };
if (!object.contains("rotation"))
object["rotation"] = QJsonObject{ { "ax", 0.0 }, { "ay", 1.0 }, { "az", 0.0 }, { "angle", 0.0 } };
if (!object.contains("shading"))
object["shading"] = "Flat";
if (!object.contains("color"))
object["color"] = QJsonObject{ { "r", conf.mesh.dc.r }, { "g", conf.mesh.dc.g }, { "b", conf.mesh.dc.b } };
if (!object.contains("voxelize"))
object["voxelize"] = true;
if (!object.contains("dynamics"))
object["dynamics"] = true;
if (!object.contains("density"))
object["density"] = 2712.0; // Density of aluminium, Iron: 7850, Steel: 7850, Brass 60/40: 8520
if (!object.contains("localRotAxis"))
object["localRotAxis"] = QJsonObject{ { "enabled", false }, { "x", 0.0f }, { "y", 0.0f }, { "z", 0.0f } };
if (!object.contains("showAccelArrow"))
object["showAccelArrow"] = false;
}
if (type == ObjectType::VoxelGrid)
{
// Verify mandatory keys for voxel grids
if (!object.contains("resolution"))
{
StaticLogger::logit("WARNING: Found no resolution for Voxel Grid '" + name + "' in project file!");
return false;
}
if (!object.contains("gridSize"))
{
StaticLogger::logit("WARNING: Found no grid size for Voxel Grid '" + name + "' in project file!");
return false;
}
// Insert all non-existent keys for voxel grids with default values
if (!object.contains("position"))
object["position"] = QJsonObject{ { "x", 0.0 }, { "y", 0.0 }, { "z", 0.0 } };
if (!object.contains("scaling"))
object["saling"] = QJsonObject{ { "x", 1.0 }, { "y", 1.0 }, { "z", 1.0 } };
if (!object.contains("rotation"))
object["rotation"] = QJsonObject{ { "ax", 0.0 }, { "ay", 1.0 }, { "az", 0.0 }, { "angle", 0.0 } };
if (!object.contains("voxel"))
object["voxel"] = VoxelGrid::getVoxelSettingsDefault();
if (!object.contains("glyphs"))
{
QJsonObject res = object["resolution"].toObject();
object["glyphs"] = VoxelGrid::getGlyphSettingsDefault(DirectX::XMUINT3(res["x"].toInt(), res["y"].toInt(), res["z"].toInt()));
}
if (!object.contains("volume"))
{
QJsonObject functions;
for (const auto& metric : Metric::names)
functions[metric] = TransferFunction().toJson();
object["volume"] = QJsonObject{ { "enabled", false }, { "stepSize", 0.5 }, { "metric", Metric::toString(Metric::Magnitude)}, { "transferFunctions", functions } };
}
if (!object.contains("windTunnelSettings"))
object["windTunnelSettings"] = ""; // Simulation uses default values
if (!object.contains("runSimulation"))
object["runSimulation"] = false;
if (!object.contains("smoke"))
{
object["smoke"] = Simulator::getSmokeSettingsDefault();
}
if (!object.contains("lines"))
object["lines"] = Simulator::getLineSettingsDefault();
}
return true;
}
ImageMapping::ImageMapping()
: ImageGLProcessor("img_mapping.frag")
, transferFunction_("transferFunction", "Transfer Function", TransferFunction()) {
addProperty(transferFunction_);
}
AxisAlignedCutPlane::AxisAlignedCutPlane()
: Processor()
, volume_("volume")
, imageInport_("imageInport_")
, outport_("outport")
, xSlide_("x", "X Slide")
, ySlide_("y", "Y Slide")
, zSlide_("z", "Z Slide")
, disableTF_("disableTF", "Disable transfer function", false,
InvalidationLevel::InvalidResources)
, tf_("transferfunction", "Transfer function", TransferFunction(), &volume_)
, sliceShader_("geometryrendering.vert", "axisalignedcutplaneslice.frag", false)
, boundingBoxShader_("geometryrendering.vert", "axisalignedcutplaneboundingbox.frag")
, showBoundingBox_("boundingBox", "Show Bounding Box", true)
, boundingBoxColor_("boundingBoxColor", "Bounding Box Color", vec4(0.0f, 0.0f, 0.0f, 1.0f))
, renderPointSize_("renderPointSize", "Point Size", 1.0f, 0.001f, 15.0f, 0.001f)
, renderLineWidth_("renderLineWidth", "Line Width", 1.0f, 0.001f, 15.0f, 0.001f)
, nearestInterpolation_("nearestInterpolation", "Use nearest neighbor interpolation", false)
, camera_("camera", "Camera")
, trackball_(&camera_) {
addPort(volume_);
addPort(imageInport_);
addPort(outport_);
addProperty(xSlide_);
addProperty(ySlide_);
addProperty(zSlide_);
addProperty(disableTF_);
addProperty(tf_);
addProperty(showBoundingBox_);
addProperty(boundingBoxColor_);
addProperty(renderPointSize_);
addProperty(renderLineWidth_);
addProperty(camera_);
addProperty(trackball_);
imageInport_.setOptional(true);
tf_.get().clearPoints();
tf_.get().addPoint(vec2(0.0f, 1.0f), vec4(0.0f, 0.0f, 0.0f, 1.0f));
tf_.get().addPoint(vec2(1.0f, 1.0f), vec4(1.0f, 1.0f, 1.0f, 1.0f));
tf_.setCurrentStateAsDefault();
xSlide_.onChange([&]() {
if (volume_.hasData()) xSlide_.createDrawer(volume_.getData());
});
ySlide_.onChange([&]() {
if (volume_.hasData()) ySlide_.createDrawer(volume_.getData());
});
zSlide_.onChange([&]() {
if (volume_.hasData()) zSlide_.createDrawer(volume_.getData());
});
volume_.onChange([&]() {
if (!volume_.hasData()) return;
auto vol = volume_.getData();
xSlide_.onVolumeChange(vol);
ySlide_.onVolumeChange(vol);
zSlide_.onVolumeChange(vol);
if (!boundingBoxMesh_) {
createBoundingBox();
}
boundingBoxMesh_->setModelMatrix(vol->getModelMatrix());
boundingBoxMesh_->setWorldMatrix(vol->getWorldMatrix());
});
boundingBoxColor_.setSemantics(PropertySemantics::Color);
setAllPropertiesCurrentStateAsDefault();
createBoundingBox();
}
