@@ -293,7 +313,7 @@ const CanvasPanel = ({ isOpen, onClose, onWidthChange }) => {
dangerouslySetInnerHTML={{ __html: sanitizedHtml }}
/>
);
- } catch (error) {
+ } catch {
// Fallback to plain text with syntax highlighting for code files
const fileExt = currentFileContent.file.filename.split('.').pop().toLowerCase();
const isCodeFile = ['js', 'py', 'java', 'cpp', 'ts', 'jsx', 'tsx', 'css', 'html', 'json', 'sql'].includes(fileExt);
diff --git a/frontend/src/components/VtkViewer.jsx b/frontend/src/components/VtkViewer.jsx
new file mode 100644
index 0000000..3422c9f
--- /dev/null
+++ b/frontend/src/components/VtkViewer.jsx
@@ -0,0 +1,605 @@
+import { useEffect, useRef, useState } from 'react'
+import { RotateCw, ZoomIn, ZoomOut, Maximize2, Scissors, Play, Pause } from 'lucide-react'
+
+// Import VTK.js modules
+import '@kitware/vtk.js/Rendering/Profiles/Geometry'
+import vtkFullScreenRenderWindow from '@kitware/vtk.js/Rendering/Misc/FullScreenRenderWindow'
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor'
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper'
+import vtkPolyDataReader from '@kitware/vtk.js/IO/Legacy/PolyDataReader'
+import vtkXMLPolyDataReader from '@kitware/vtk.js/IO/XML/XMLPolyDataReader'
+import vtkSTLReader from '@kitware/vtk.js/IO/Geometry/STLReader'
+import vtkOBJReader from '@kitware/vtk.js/IO/Misc/OBJReader'
+import vtkPLYReader from '@kitware/vtk.js/IO/Geometry/PLYReader'
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane'
+import vtkPolyDataNormals from '@kitware/vtk.js/Filters/Core/PolyDataNormals'
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction'
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps'
+
+const VtkViewer = ({ fileContent, filename }) => {
+ const containerRef = useRef(null)
+ const fullScreenRendererRef = useRef(null)
+ const polyDataRef = useRef(null)
+ const autoRotateIntervalRef = useRef(null)
+ const [isLoading, setIsLoading] = useState(true)
+ const [error, setError] = useState(null)
+ const [slicingEnabled, setSlicingEnabled] = useState(false)
+ const [slicePosition, setSlicePosition] = useState(50)
+ const [sliceAxis, setSliceAxis] = useState('z')
+ const [customNormal, setCustomNormal] = useState({ x: 0, y: 0, z: 1 })
+ const [isAutoRotating, setIsAutoRotating] = useState(false)
+ const [scalarArrays, setScalarArrays] = useState([])
+ const [activeScalar, setActiveScalar] = useState(null)
+ const [flipClipping, setFlipClipping] = useState(false)
+
+ useEffect(() => {
+ if (!containerRef.current || !fileContent) {
+ return
+ }
+
+ let fullScreenRenderer = null
+ let actor = null
+
+ const initializeViewer = async () => {
+ try {
+ setIsLoading(true)
+ setError(null)
+
+ // Clear any existing content
+ if (containerRef.current) {
+ containerRef.current.innerHTML = ''
+ }
+
+ // Create full screen render window
+ fullScreenRenderer = vtkFullScreenRenderWindow.newInstance({
+ container: containerRef.current,
+ background: [0.1, 0.1, 0.1]
+ })
+ fullScreenRendererRef.current = fullScreenRenderer
+
+ const renderer = fullScreenRenderer.getRenderer()
+ const renderWindow = fullScreenRenderer.getRenderWindow()
+
+ // Get the appropriate reader based on file extension
+ const extension = filename.toLowerCase().split('.').pop()
+ let reader = null
+
+ // Convert content to ArrayBuffer if it's a string (base64)
+ let arrayBuffer
+ if (typeof fileContent === 'string') {
+ // Assume base64 encoded
+ const binaryString = atob(fileContent)
+ const bytes = new Uint8Array(binaryString.length)
+ for (let i = 0; i < binaryString.length; i++) {
+ bytes[i] = binaryString.charCodeAt(i)
+ }
+ arrayBuffer = bytes.buffer
+ } else if (fileContent instanceof ArrayBuffer) {
+ arrayBuffer = fileContent
+ } else if (fileContent instanceof Blob) {
+ arrayBuffer = await fileContent.arrayBuffer()
+ } else {
+ throw new Error('Unsupported content type')
+ }
+
+ // Select appropriate reader based on file type
+ switch (extension) {
+ case 'vtk':
+ reader = vtkPolyDataReader.newInstance()
+ // Legacy VTK format uses parseAsText for ASCII files
+ if (typeof fileContent === 'string') {
+ // If we have base64 string, decode to text first
+ const textContent = new TextDecoder().decode(arrayBuffer)
+ reader.parseAsText(textContent)
+ } else {
+ // For binary content, convert ArrayBuffer to string
+ const textContent = new TextDecoder().decode(arrayBuffer)
+ reader.parseAsText(textContent)
+ }
+ break
+ case 'vtp':
+ case 'vtu':
+ case 'vti':
+ case 'vts':
+ case 'vtr':
+ reader = vtkXMLPolyDataReader.newInstance()
+ reader.parseAsArrayBuffer(arrayBuffer)
+ break
+ case 'stl':
+ reader = vtkSTLReader.newInstance()
+ reader.parseAsArrayBuffer(arrayBuffer)
+ break
+ case 'obj':
+ reader = vtkOBJReader.newInstance()
+ reader.parseAsArrayBuffer(arrayBuffer)
+ break
+ case 'ply':
+ reader = vtkPLYReader.newInstance()
+ reader.parseAsArrayBuffer(arrayBuffer)
+ break
+ default:
+ throw new Error(`Unsupported file format: ${extension}`)
+ }
+
+ // Store polydata for slicing operations
+ const polyData = reader.getOutputData()
+ polyDataRef.current = polyData
+
+ // Extract available scalar arrays
+ const pointData = polyData.getPointData()
+ const availableScalars = []
+ for (let i = 0; i < pointData.getNumberOfArrays(); i++) {
+ const array = pointData.getArray(i)
+ const arrayName = array.getName()
+ if (arrayName) {
+ availableScalars.push({
+ name: arrayName,
+ range: array.getRange()
+ })
+ }
+ }
+ setScalarArrays(availableScalars)
+
+ // Auto-select first scalar if available
+ if (availableScalars.length > 0 && !activeScalar) {
+ setActiveScalar(availableScalars[0].name)
+ }
+
+ // Compute normals if not present (fixes WebGL samplerBuffer errors)
+ const normalsFilter = vtkPolyDataNormals.newInstance()
+ normalsFilter.setInputConnection(reader.getOutputPort())
+ normalsFilter.setComputePointNormals(true)
+ normalsFilter.setComputeCellNormals(false)
+
+ // Create mapper
+ const mapper = vtkMapper.newInstance()
+ mapper.setInputConnection(normalsFilter.getOutputPort())
+
+ // Enable scalar coloring if we have scalar data
+ if (availableScalars.length > 0) {
+ // Create color transfer function (rainbow color map)
+ const lookupTable = vtkColorTransferFunction.newInstance()
+ const preset = vtkColorMaps.getPresetByName('erdc_rainbow_bright')
+ lookupTable.applyColorMap(preset)
+ lookupTable.setMappingRange(...availableScalars[0].range)
+ lookupTable.updateRange()
+
+ // Configure mapper for scalar coloring
+ mapper.setLookupTable(lookupTable)
+ mapper.setScalarRange(...availableScalars[0].range)
+ mapper.setScalarVisibility(true)
+ mapper.setScalarModeToUsePointFieldData()
+ mapper.setColorByArrayName(availableScalars[0].name)
+ }
+
+ // Create actor
+ actor = vtkActor.newInstance()
+ actor.setMapper(mapper)
+
+ // Set properties only if NOT using scalar coloring
+ if (availableScalars.length === 0) {
+ actor.getProperty().setColor(0.8, 0.8, 0.9)
+ }
+ actor.getProperty().setAmbient(0.3)
+ actor.getProperty().setDiffuse(0.7)
+ actor.getProperty().setSpecular(0.3)
+ actor.getProperty().setSpecularPower(30)
+
+ // Add actor to renderer
+ renderer.addActor(actor)
+ renderer.resetCamera()
+ renderWindow.render()
+
+ setIsLoading(false)
+ } catch (err) {
+ console.error('Error loading VTK file:', err)
+ setError(err.message || 'Failed to load file')
+ setIsLoading(false)
+ }
+ }
+
+ initializeViewer()
+
+ // Cleanup function
+ return () => {
+ if (fullScreenRendererRef.current) {
+ fullScreenRendererRef.current.delete()
+ fullScreenRendererRef.current = null
+ }
+ if (actor) {
+ actor.delete()
+ }
+ }
+ }, [fileContent, filename])
+
+ const handleResetView = () => {
+ if (fullScreenRendererRef.current) {
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ renderer.resetCamera()
+ renderWindow.render()
+ }
+ }
+
+ const handleZoomIn = () => {
+ if (fullScreenRendererRef.current) {
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ const camera = renderer.getActiveCamera()
+ camera.zoom(1.2)
+ renderWindow.render()
+ }
+ }
+
+ const handleZoomOut = () => {
+ if (fullScreenRendererRef.current) {
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ const camera = renderer.getActiveCamera()
+ camera.zoom(0.8)
+ renderWindow.render()
+ }
+ }
+
+ const toggleSlicing = () => {
+ setSlicingEnabled(!slicingEnabled)
+ }
+
+ const toggleAutoRotate = () => {
+ setIsAutoRotating(!isAutoRotating)
+ }
+
+ // Auto-rotation effect
+ useEffect(() => {
+ if (!isAutoRotating || !fullScreenRendererRef.current) {
+ if (autoRotateIntervalRef.current) {
+ clearInterval(autoRotateIntervalRef.current)
+ autoRotateIntervalRef.current = null
+ }
+ return
+ }
+
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ const camera = renderer.getActiveCamera()
+
+ autoRotateIntervalRef.current = setInterval(() => {
+ camera.azimuth(0.5) // Rotate 0.5 degrees per frame (slow rotation)
+ renderer.resetCameraClippingRange() // Fix clipping issues during rotation
+ renderWindow.render()
+ }, 33) // ~30 fps
+
+ return () => {
+ if (autoRotateIntervalRef.current) {
+ clearInterval(autoRotateIntervalRef.current)
+ autoRotateIntervalRef.current = null
+ }
+ }
+ }, [isAutoRotating])
+
+ // Update custom normal when axis changes
+ useEffect(() => {
+ if (sliceAxis === 'x') {
+ setCustomNormal({ x: 1, y: 0, z: 0 })
+ } else if (sliceAxis === 'y') {
+ setCustomNormal({ x: 0, y: 1, z: 0 })
+ } else if (sliceAxis === 'z') {
+ setCustomNormal({ x: 0, y: 0, z: 1 })
+ }
+ }, [sliceAxis])
+
+ // Apply slicing when enabled or slice parameters change
+ useEffect(() => {
+ if (!fullScreenRendererRef.current || !polyDataRef.current) {
+ return
+ }
+
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ const actors = renderer.getActors()
+
+ if (actors.length === 0) return
+
+ const actor = actors[0]
+ const mapper = actor.getMapper()
+
+ // Remove all existing clipping planes
+ mapper.removeAllClippingPlanes()
+
+ if (slicingEnabled) {
+ // Get bounds of the data
+ const bounds = polyDataRef.current.getBounds()
+ const [xMin, xMax, yMin, yMax, zMin, zMax] = bounds
+
+ // Create clipping plane
+ const plane = vtkPlane.newInstance()
+
+ // Calculate position based on slice percentage
+ let position
+ if (sliceAxis === 'x') {
+ position = xMin + (xMax - xMin) * (slicePosition / 100)
+ } else if (sliceAxis === 'y') {
+ position = yMin + (yMax - yMin) * (slicePosition / 100)
+ } else { // z
+ position = zMin + (zMax - zMin) * (slicePosition / 100)
+ }
+
+ // Set plane origin (at calculated position along the axis)
+ const origin = [
+ sliceAxis === 'x' ? position : 0,
+ sliceAxis === 'y' ? position : 0,
+ sliceAxis === 'z' ? position : 0
+ ]
+
+ plane.setOrigin(origin[0], origin[1], origin[2])
+
+ // Apply normal direction (flip if requested)
+ const normalDirection = flipClipping ? -1 : 1
+ plane.setNormal(
+ customNormal.x * normalDirection,
+ customNormal.y * normalDirection,
+ customNormal.z * normalDirection
+ )
+
+ // Add clipping plane to mapper
+ mapper.addClippingPlane(plane)
+
+ // Important: Call modified() to trigger update
+ mapper.modified()
+ }
+
+ renderWindow.render()
+ }, [slicingEnabled, slicePosition, sliceAxis, customNormal, flipClipping])
+
+ // Update scalar field coloring
+ useEffect(() => {
+ if (!fullScreenRendererRef.current) {
+ return
+ }
+
+ const renderer = fullScreenRendererRef.current.getRenderer()
+ const renderWindow = fullScreenRendererRef.current.getRenderWindow()
+ const actors = renderer.getActors()
+
+ if (actors.length === 0) return
+
+ const actor = actors[0]
+ const mapper = actor.getMapper()
+
+ if (!activeScalar) {
+ // Disable scalar coloring, use solid color
+ mapper.setScalarVisibility(false)
+ actor.getProperty().setColor(0.8, 0.8, 0.9)
+ } else {
+ // Find the selected scalar array
+ const scalarInfo = scalarArrays.find(s => s.name === activeScalar)
+ if (scalarInfo) {
+ // Create/update color transfer function
+ const lookupTable = vtkColorTransferFunction.newInstance()
+ const preset = vtkColorMaps.getPresetByName('erdc_rainbow_bright')
+ lookupTable.applyColorMap(preset)
+ lookupTable.setMappingRange(...scalarInfo.range)
+ lookupTable.updateRange()
+
+ // Configure mapper
+ mapper.setLookupTable(lookupTable)
+ mapper.setScalarRange(...scalarInfo.range)
+ mapper.setScalarVisibility(true)
+ mapper.setScalarModeToUsePointFieldData()
+ mapper.setColorByArrayName(activeScalar)
+ }
+ }
+
+ mapper.modified()
+ renderWindow.render()
+ }, [activeScalar, scalarArrays])
+
+ return (
+
+ {isLoading && (
+
+ )}
+
+ {error && (
+
+
+
Error loading 3D model
+
{error}
+
+
+ )}
+
+
+
+ {!isLoading && !error && (
+
+
+
+
+
+
+
+ )}
+
+ {!isLoading && !error && scalarArrays.length > 0 && (
+
+
Color By Scalar Field
+
+ {activeScalar && (
+
+ Range: {scalarArrays.find(s => s.name === activeScalar)?.range.map(v => v.toExponential(2)).join(' to ')}
+
+ )}
+
+ )}
+
+ {!isLoading && !error && slicingEnabled && (
+
+
Section View Controls
+
+ {/* Preset axis buttons */}
+
+
Quick Axes
+
+
+
+
+
+
+
+ {/* Custom normal direction */}
+
+
Plane Normal Direction
+
+
+
+ {/* Position slider - larger */}
+
+
Plane Position: {slicePosition}%
+
setSlicePosition(Number(e.target.value))}
+ className="w-full h-3 bg-gray-700 rounded-lg appearance-none cursor-pointer slider"
+ style={{
+ background: `linear-gradient(to right, #3b82f6 0%, #3b82f6 ${slicePosition}%, #374151 ${slicePosition}%, #374151 100%)`
+ }}
+ />
+
+
+ {/* Flip clipping direction toggle */}
+
+ Flip Clipping Direction
+
+
+
+ )}
+
+ {!isLoading && !error && (
+
+ Left-click: Rotate | Right-click: Pan | Scroll: Zoom
+
+ )}
+
+ )
+}
+
+export default VtkViewer
diff --git a/frontend/src/hooks/chat/useFiles.js b/frontend/src/hooks/chat/useFiles.js
index 37a9179..5959414 100644
--- a/frontend/src/hooks/chat/useFiles.js
+++ b/frontend/src/hooks/chat/useFiles.js
@@ -11,6 +11,8 @@ function getFileType(filename) {
if (['png', 'jpg', 'jpeg', 'gif', 'svg'].includes(extension)) return 'image'
if (extension === 'pdf') return 'pdf'
if (extension === 'html') return 'html'
+ // Engineering/scientific visualization file formats
+ if (['vtk', 'vtp', 'vtu', 'vti', 'vts', 'vtr', 'stl', 'obj', 'ply', 'gltf', 'glb'].includes(extension)) return 'vtk'
return 'other'
}
diff --git a/frontend/src/test/vtk-file-types.test.js b/frontend/src/test/vtk-file-types.test.js
new file mode 100644
index 0000000..15506e8
--- /dev/null
+++ b/frontend/src/test/vtk-file-types.test.js
@@ -0,0 +1,119 @@
+/**
+ * Tests for VTK file type detection and handling
+ */
+
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useFiles } from '../hooks/chat/useFiles';
+
+describe('VTK File Type Detection', () => {
+ it('should detect VTK format files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('model.vtk')).toBe('vtk');
+ expect(getFileType('MODEL.VTK')).toBe('vtk');
+ });
+
+ it('should detect VTP (VTK PolyData) files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('mesh.vtp')).toBe('vtk');
+ expect(getFileType('MESH.VTP')).toBe('vtk');
+ });
+
+ it('should detect VTU (VTK Unstructured Grid) files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('simulation.vtu')).toBe('vtk');
+ });
+
+ it('should detect STL files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('part.stl')).toBe('vtk');
+ expect(getFileType('PART.STL')).toBe('vtk');
+ });
+
+ it('should detect OBJ files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('model.obj')).toBe('vtk');
+ });
+
+ it('should detect PLY files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('scan.ply')).toBe('vtk');
+ });
+
+ it('should detect VTI (VTK Image Data) files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('volume.vti')).toBe('vtk');
+ });
+
+ it('should detect VTS (VTK Structured Grid) files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('grid.vts')).toBe('vtk');
+ });
+
+ it('should detect VTR (VTK Rectilinear Grid) files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('rectilinear.vtr')).toBe('vtk');
+ });
+
+ it('should detect GLTF files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('scene.gltf')).toBe('vtk');
+ });
+
+ it('should detect GLB files', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('model.glb')).toBe('vtk');
+ });
+
+ it('should detect image files correctly', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('photo.png')).toBe('image');
+ expect(getFileType('photo.jpg')).toBe('image');
+ });
+
+ it('should detect PDF files correctly', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('document.pdf')).toBe('pdf');
+ });
+
+ it('should detect HTML files correctly', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('page.html')).toBe('html');
+ });
+
+ it('should return other for unknown file types', () => {
+ const { result } = renderHook(() => useFiles());
+ const { getFileType } = result.current;
+
+ expect(getFileType('file.xyz')).toBe('other');
+ expect(getFileType('file.unknown')).toBe('other');
+ });
+});
diff --git a/scripts/generate_vtk_samples.py b/scripts/generate_vtk_samples.py
new file mode 100755
index 0000000..37b387b
--- /dev/null
+++ b/scripts/generate_vtk_samples.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Simple script to generate a sample VTK file for testing the VTK viewer.
+This creates a simple cube mesh in VTK legacy ASCII format.
+"""
+
+def generate_simple_cube_vtk():
+ """Generate a simple cube in VTK legacy format."""
+ vtk_content = """# vtk DataFile Version 3.0
+Simple Cube for Testing
+ASCII
+DATASET POLYDATA
+POINTS 8 float
+0.0 0.0 0.0
+1.0 0.0 0.0
+1.0 1.0 0.0
+0.0 1.0 0.0
+0.0 0.0 1.0
+1.0 0.0 1.0
+1.0 1.0 1.0
+0.0 1.0 1.0
+
+POLYGONS 6 30
+4 0 1 2 3
+4 4 5 6 7
+4 0 1 5 4
+4 2 3 7 6
+4 0 3 7 4
+4 1 2 6 5
+"""
+ return vtk_content
+
+
+def generate_simple_sphere_vtk():
+ """Generate a simple sphere using parametric equations."""
+ import math
+
+ # Sphere parameters
+ radius = 1.0
+ u_resolution = 20
+ v_resolution = 20
+
+ points = []
+ polygons = []
+
+ # Generate points
+ for i in range(u_resolution + 1):
+ u = (i / u_resolution) * 2 * math.pi
+ for j in range(v_resolution + 1):
+ v = (j / v_resolution) * math.pi
+ x = radius * math.sin(v) * math.cos(u)
+ y = radius * math.sin(v) * math.sin(u)
+ z = radius * math.cos(v)
+ points.append(f"{x:.6f} {y:.6f} {z:.6f}")
+
+ # Generate polygons (quads)
+ for i in range(u_resolution):
+ for j in range(v_resolution):
+ p0 = i * (v_resolution + 1) + j
+ p1 = (i + 1) * (v_resolution + 1) + j
+ p2 = (i + 1) * (v_resolution + 1) + (j + 1)
+ p3 = i * (v_resolution + 1) + (j + 1)
+ polygons.append(f"4 {p0} {p1} {p2} {p3}")
+
+ vtk_content = f"""# vtk DataFile Version 3.0
+Simple Sphere for Testing
+ASCII
+DATASET POLYDATA
+POINTS {len(points)} float
+{chr(10).join(points)}
+
+POLYGONS {len(polygons)} {len(polygons) * 5}
+{chr(10).join(polygons)}
+"""
+ return vtk_content
+
+
+def generate_sample_stl():
+ """Generate a simple pyramid in STL ASCII format."""
+ stl_content = """solid SimplePyramid
+ facet normal 0.0 -0.8944271909999159 0.4472135954999579
+ outer loop
+ vertex 0.0 0.0 0.0
+ vertex 1.0 0.0 0.0
+ vertex 0.5 0.5 1.0
+ endloop
+ endfacet
+ facet normal 0.8944271909999159 0.0 0.4472135954999579
+ outer loop
+ vertex 1.0 0.0 0.0
+ vertex 1.0 1.0 0.0
+ vertex 0.5 0.5 1.0
+ endloop
+ endfacet
+ facet normal 0.0 0.8944271909999159 0.4472135954999579
+ outer loop
+ vertex 1.0 1.0 0.0
+ vertex 0.0 1.0 0.0
+ vertex 0.5 0.5 1.0
+ endloop
+ endfacet
+ facet normal -0.8944271909999159 0.0 0.4472135954999579
+ outer loop
+ vertex 0.0 1.0 0.0
+ vertex 0.0 0.0 0.0
+ vertex 0.5 0.5 1.0
+ endloop
+ endfacet
+ facet normal 0.0 0.0 -1.0
+ outer loop
+ vertex 0.0 0.0 0.0
+ vertex 1.0 1.0 0.0
+ vertex 1.0 0.0 0.0
+ endloop
+ endfacet
+ facet normal 0.0 0.0 -1.0
+ outer loop
+ vertex 0.0 0.0 0.0
+ vertex 0.0 1.0 0.0
+ vertex 1.0 1.0 0.0
+ endloop
+ endfacet
+endsolid SimplePyramid
+"""
+ return stl_content
+
+
+if __name__ == "__main__":
+ import sys
+ import os
+
+ # Create test_data directory if it doesn't exist
+ test_dir = os.path.join(os.path.dirname(__file__), "..", "test_data", "vtk_samples")
+ os.makedirs(test_dir, exist_ok=True)
+
+ # Generate cube
+ cube_file = os.path.join(test_dir, "cube.vtk")
+ with open(cube_file, "w") as f:
+ f.write(generate_simple_cube_vtk())
+ print(f"Generated: {cube_file}")
+
+ # Generate sphere
+ sphere_file = os.path.join(test_dir, "sphere.vtk")
+ with open(sphere_file, "w") as f:
+ f.write(generate_simple_sphere_vtk())
+ print(f"Generated: {sphere_file}")
+
+ # Generate pyramid STL
+ pyramid_file = os.path.join(test_dir, "pyramid.stl")
+ with open(pyramid_file, "w") as f:
+ f.write(generate_sample_stl())
+ print(f"Generated: {pyramid_file}")
+
+ print("\nSample VTK files generated successfully!")
+ print(f"Files are located in: {test_dir}")
+ print("\nYou can upload these files to test the VTK viewer:")
+ print("1. Upload via chat interface")
+ print("2. Ask the AI to visualize them in the canvas")