Übersicht über das Volumerendering
Informationen zu medizinischen MRT- oder Technischen Volumes finden Sie unter Volume Rendering auf Wikipedia. Diese "volumetrischen Bilder" enthalten umfangreiche Informationen mit Deckkraft und Farbe im gesamten Volume, die nicht einfach als Oberflächen wie polygonale Gitter ausgedrückt werden können.
Wichtige Lösungen zur Verbesserung der Leistung
- SCHLECHT: Naive Ansatz: Show Whole Volume, läuft in der Regel zu langsam
- GUT: Schnittebene: Nur ein einzelnes Segment des Volumes anzeigen
- GUT: Teilvolume schneiden: Nur wenige Ebenen des Volumes anzeigen
- GUT: Verringern der Auflösung des Volumerenderings (siehe "Szenenrendering mit gemischter Auflösung")
Es gibt nur eine bestimmte Menge an Informationen, die in einem bestimmten Frame von der Anwendung auf den Bildschirm übertragen werden können, d. h. die Gesamtspeicherbandbreite. Darüber hinaus erfordert jede Verarbeitung (oder "Schattierung"), die zum Transformieren dieser Daten für die Präsentation erforderlich ist, Zeit. Die wichtigsten Überlegungen beim Rendern von Volumes sind folgende:
- Screen-Width * Screen-Height * Screen-Count * Volume-Layers-On-that-Pixel = Total-Volume-Samples-per-frame
- 1028 * 720 * 2 * 256 = 378961920 (100%) (full res volume: too many samples)
- 1028 * 720 * 2 * 1 = 1480320 (0,3% der voll) (dünne Scheibe: 1 Probe pro Pixel, läuft reibungslos)
- 1028 * 720 * 2 * 10 = 14803200 (3,9% des vollständigen) (Teilvolume-Slice: 10 Stichproben pro Pixel, läuft ziemlich reibungslos, sieht 3D aus)
- 200 * 200 * 2 * 256 = 20480000 (5% des vollen Volumens) (geringere Res-Volumen: weniger Pixel, volle Lautstärke, sieht 3D aus, aber ein bisschen unscharf)
Darstellen von 3D-Texturen
Auf der CPU:
public struct Int3 { public int X, Y, Z; /* ... */ }
public class VolumeHeader {
public readonly Int3 Size;
public VolumeHeader(Int3 size) { this.Size = size; }
public int CubicToLinearIndex(Int3 index) {
return index.X + (index.Y * (Size.X)) + (index.Z * (Size.X * Size.Y));
}
public Int3 LinearToCubicIndex(int linearIndex)
{
return new Int3((linearIndex / 1) % Size.X,
(linearIndex / Size.X) % Size.Y,
(linearIndex / (Size.X * Size.Y)) % Size.Z);
}
/* ... */
}
public class VolumeBuffer<T> {
public readonly VolumeHeader Header;
public readonly T[] DataArray;
public T GetVoxel(Int3 pos) {
return this.DataArray[this.Header.CubicToLinearIndex(pos)];
}
public void SetVoxel(Int3 pos, T val) {
this.DataArray[this.Header.CubicToLinearIndex(pos)] = val;
}
public T this[Int3 pos] {
get { return this.GetVoxel(pos); }
set { this.SetVoxel(pos, value); }
}
/* ... */
}
Auf der GPU:
float3 _VolBufferSize;
int3 UnitVolumeToIntVolume(float3 coord) {
return (int3)( coord * _VolBufferSize.xyz );
}
int IntVolumeToLinearIndex(int3 coord, int3 size) {
return coord.x + ( coord.y * size.x ) + ( coord.z * ( size.x * size.y ) );
}
uniform StructuredBuffer<float> _VolBuffer;
float SampleVol(float3 coord3 ) {
int3 intIndex3 = UnitVolumeToIntVolume( coord3 );
int index1D = IntVolumeToLinearIndex( intIndex3, _VolBufferSize.xyz);
return __VolBuffer[index1D];
}
Schattierung und Farbverläufe
Hier erfahren Sie, wie Sie ein Volume, z. B. MRT, für eine nützliche Visualisierung schattieren. Die primäre Methode besteht darin, ein "Intensitätsfenster" (min und max) zu haben, in dem Intensitäten angezeigt werden sollen, und einfach in diesen Bereich skalieren, um die Schwarz-Weiß-Intensität zu sehen. Eine "Farbrampe" kann dann auf die Werte innerhalb dieses Bereichs angewendet und als Textur gespeichert werden, sodass verschiedene Teile des Intensitätsspektrums unterschiedliche Farben schattiert werden können:
float4 ShadeVol( float intensity ) {
float unitIntensity = saturate( intensity - IntensityMin / ( IntensityMax - IntensityMin ) );
// Simple two point black and white intensity:
color.rgba = unitIntensity;
// Color ramp method:
color.rgba = tex2d( ColorRampTexture, float2( unitIntensity, 0 ) );
In vielen unserer Anwendungen speichern wir in unserem Volumen sowohl einen rohen Intensitätswert als auch einen "Segmentierungsindex" (um verschiedene Teile wie Haut und Knochen zu segmentieren; diese Segmente werden von Experten mit dedizierten Tools erstellt). Dies kann mit dem oben genannten Ansatz kombiniert werden, um eine andere Farbe oder sogar eine andere Farbskala für jeden Segmentindex zu setzen:
// Change color to match segment index (fade each segment towards black):
color.rgb = SegmentColors[ segment_index ] * color.a; // brighter alpha gives brighter color
Volume Slicing in einem Shader
Ein guter erster Schritt besteht darin, eine "Aufschnittebene" zu erstellen, die sich durch das Volume bewegen, es aufteilen kann und wie die Scanwerte an jedem Punkt sind. Dies setzt voraus, dass es einen "VolumeSpace"-Cube gibt, der darstellt, wo sich das Volume im Weltraum befindet, der als Referenz zum Platzieren der Punkte verwendet werden kann:
// In the vertex shader:
float4 worldPos = mul(_Object2World, float4(input.vertex.xyz, 1));
float4 volSpace = mul(_WorldToVolume, float4(worldPos, 1));
// In the pixel shader:
float4 color = ShadeVol( SampleVol( volSpace ) );
Volumeablaufverfolgung in Shadern
Verwenden der GPU zum Durchführen der Subvolume-Ablaufverfolgung (durchläuft einige Voxels tief, dann Ebenen für die Daten von hinten nach vorne):
float4 AlphaBlend(float4 dst, float4 src) {
float4 res = (src * src.a) + (dst - dst * src.a);
res.a = src.a + (dst.a - dst.a*src.a);
return res;
}
float4 volTraceSubVolume(float3 objPosStart, float3 cameraPosVolSpace) {
float maxDepth = 0.15; // depth in volume space, customize!!!
float numLoops = 10; // can be 400 on nice PC
float4 curColor = float4(0, 0, 0, 0);
// Figure out front and back volume coords to walk through:
float3 frontCoord = objPosStart;
float3 backCoord = frontPos + (normalize(cameraPosVolSpace - objPosStart) * maxDepth);
float3 stepCoord = (frontCoord - backCoord) / numLoops;
float3 curCoord = backCoord;
// Add per-pixel random offset, avoids layer aliasing:
curCoord += stepCoord * RandomFromPositionFast(objPosStart);
// Walk from back to front (to make front appear in-front of back):
for (float i = 0; i < numLoops; i++) {
float intensity = SampleVol(curCoord);
float4 shaded = ShadeVol(intensity);
curColor = AlphaBlend(curColor, shaded);
curCoord += stepCoord;
}
return curColor;
}
// In the vertex shader:
float4 worldPos = mul(_Object2World, float4(input.vertex.xyz, 1));
float4 volSpace = mul(_WorldToVolume, float4(worldPos.xyz, 1));
float4 cameraInVolSpace = mul(_WorldToVolume, float4(_WorldSpaceCameraPos.xyz, 1));
// In the pixel shader:
float4 color = volTraceSubVolume( volSpace, cameraInVolSpace );
Rendering des gesamten Volumes
Wenn Sie den obigen Untervolumcode ändern, erhalten Sie Folgendes:
float4 volTraceSubVolume(float3 objPosStart, float3 cameraPosVolSpace) {
float maxDepth = 1.73; // sqrt(3), max distance from point on cube to any other point on cube
int maxSamples = 400; // just in case, keep this value within bounds
// not shown: trim front and back positions to both be within the cube
int distanceInVoxels = length(UnitVolumeToIntVolume(frontPos - backPos)); // measure distance in voxels
int numLoops = min( distanceInVoxels, maxSamples ); // put a min on the voxels to sample
Szenenrendering mit gemischter Auflösung
So rendert man einen Teil der Szene mit einer niedrigen Auflösung und setzt ihn wieder ein:
- Richten Sie zwei Off-Screen-Kameras ein, eine, um jedem Auge zu folgen, die jeden Frame aktualisieren
- Richten Sie zwei Renderziele mit niedriger Auflösung (jeweils 200 x 200) ein, in die die Kameras gerendert werden.
- Einrichten eines Quads, das sich vor dem Benutzer bewegt
Jeder Frame:
- Zeichnen sie die Renderziele für jedes Auge mit niedriger Auflösung (Volumendaten, teure Shader usw.)
- Zeichnen Sie die Szene normal in voller Auflösung (Gitter, Benutzeroberfläche usw.)
- Zeichnen Sie ein Quad vor dem Benutzer, über die Szene, und projizieren Sie die Low-Res-Renders auf diese
- Ergebnis: Visuelle Kombination von Elementen mit voller Auflösung mit Daten mit geringer Auflösung, aber mit hoher Dichte