Re: Is there any way to prepare datasets for vtk.js?

classic Classic list List threaded Threaded
3 messages Options
Reply | Threaded
Open this post in threaded view
|

Re: Is there any way to prepare datasets for vtk.js?

Aron Helser
Hi Alexey,
references this macro from vtk-js: Utilities/ParaView/export-scene-macro.py
It can be used to export a scene from ParaView for consumption by vtk-js. 

I know there are other ways to do it as well, but that was the easiest.
HTH,
Aron

On Wed, Jul 11, 2018 at 5:54 AM Alexey Pechnikov <[hidden email]> wrote:
Hi,

I couldn't find any documentation or tool to do it. Google doesn't know anything about "vti-web" data format. VTK/VTI and other VTK formats are not allowed I see. Is disassembling example datasets and build own tools the only possible way?!

--
Best regards, Alexey Pechnikov.
_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers

_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers
Reply | Threaded
Open this post in threaded view
|

Re: Is there any way to prepare datasets for vtk.js?

Aron Helser
Adding back the mailing list....

Alexey,
Do you have a particular goal, or do you just want to try out vtk-js? If you just want to see what it can do, it is used the rendering in ParaView Glance, which you can try out here:
It will load several different data formats, or just start with the example datasets. As you can see, vtk-js is used for real and useful projects.

For just VTK-js, the example applications like the OBJ viewer: https://kitware.github.io/vtk-js/examples/OBJViewer.html
are a good starting point - there are several that will load different formats of data.

The script I pointed you at is a ParaView macro, which means that after running the ParaView application, you add it by going to the Macro menu and choosing 'Add new macro...'

Regards,
Aron

On Wed, Jul 11, 2018 at 9:59 AM Alexey Pechnikov <[hidden email]> wrote:
Aron,

That script doesn't work in python2/python3 (there is no paraview extension) and it doesn't work in internal Paraview Python shell. Maybe do you know some working way? Or do you mean I need to write my own script using this one instead of normal documentation? Is vtk-js used by somebody or it's only just to fun unuseful project? Maybe I don't need to try it actually.

2018-07-11 20:16 GMT+07:00 Aron Helser <[hidden email]>:
Hi Alexey,
references this macro from vtk-js: Utilities/ParaView/export-scene-macro.py
It can be used to export a scene from ParaView for consumption by vtk-js. 

I know there are other ways to do it as well, but that was the easiest.
HTH,
Aron

On Wed, Jul 11, 2018 at 5:54 AM Alexey Pechnikov <[hidden email]> wrote:
Hi,

I couldn't find any documentation or tool to do it. Google doesn't know anything about "vti-web" data format. VTK/VTI and other VTK formats are not allowed I see. Is disassembling example datasets and build own tools the only possible way?!

--
Best regards, Alexey Pechnikov.
_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers



--
Best regards, Alexey Pechnikov.

_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers
Reply | Threaded
Open this post in threaded view
|

Re: Is there any way to prepare datasets for vtk.js?

Aron Helser
Yes, the example data files are usually small, because they have to be delivered over the network. I don't think there is anything to prevent a large file from working locally - are you seeing particular errors with your data file? It could be it is just slow to load. Also, I was getting a blank window with some of the ParaView Glance examples with the nightly build - you might try the 'stable' build instead, which worked for me. https://kitware.github.io/paraview-glance/

I don't know why you are seeing the error in the paraview macro - it could be a version mismatch. I am not sure which version of ParaView is required.

On Wed, Jul 11, 2018 at 10:29 AM Alexey Pechnikov <[hidden email]> wrote:
Aron,

Thank you for the links! I just want to try it. As sample I have large enough 3D grid (~100MB) that I want to show it by vtk-js. I don't know how to work with large files by vtk-js... maybe need I use small reducted dataset for 3D preview and load full slices from server?

I found aneurism.vti viewer at https://kitware.github.io/paraview-glance/nightly It looks very interesting but the used datafile is small here.


Sorry, the script doesn't work as Paraview macro:

ERROR: In /Users/kitware/dashboards/buildbot-slave/8275bd07/build/superbuild/paraview/src/VTK/Rendering/OpenGL2/vtkShaderProgram.cxx, line 445

vtkShaderProgram (0x60c00058d5b0): 1: #version 150

2: #ifdef GL_ES

3: #if __VERSION__ == 300

4: #define varying in

5: #ifdef GL_FRAGMENT_PRECISION_HIGH

6: precision highp float;

7: precision highp sampler2D;

8: precision highp sampler3D;

9: #else

10: precision mediump float;

11: precision mediump sampler2D;

12: precision mediump sampler3D;

13: #endif

14: #define texelFetchBuffer texelFetch

15: #define texture1D texture

16: #define texture2D texture

17: #define texture3D texture

18: #endif // 300

19: #else // GL_ES

20: #define highp

21: #define mediump

22: #define lowp

23: #if __VERSION__ == 150

24: #define varying in

25: #define texelFetchBuffer texelFetch

26: #define texture1D texture

27: #define texture2D texture

28: #define texture3D texture

29: #endif

30: #if __VERSION__ == 120

31: #extension GL_EXT_gpu_shader4 : require

32: #endif

33: #endif // GL_ES

34:

35:

36: /*=========================================================================

37:

38: Program: Visualization Toolkit

39: Module: raycasterfs.glsl

40:

41: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

42: All rights reserved.

43: See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

44:

45: This software is distributed WITHOUT ANY WARRANTY; without even

46: the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

47: PURPOSE. See the above copyright notice for more information.

48:

49: =========================================================================*/

50:

51: //////////////////////////////////////////////////////////////////////////////

52: ///

53: /// Inputs

54: ///

55: //////////////////////////////////////////////////////////////////////////////

56:

57: /// 3D texture coordinates form vertex shader

58: varying vec3 ip_textureCoords;

59: varying vec3 ip_vertexPos;

60:

61: //////////////////////////////////////////////////////////////////////////////

62: ///

63: /// Outputs

64: ///

65: //////////////////////////////////////////////////////////////////////////////

66:

67: vec4 g_fragColor = vec4(0.0);

68:

69: //////////////////////////////////////////////////////////////////////////////

70: ///

71: /// Uniforms, attributes, and globals

72: ///

73: //////////////////////////////////////////////////////////////////////////////

74: vec3 g_dataPos;

75: vec3 g_dirStep;

76: vec4 g_srcColor;

77: vec4 g_eyePosObj;

78: bool g_exit;

79: bool g_skip;

80: float g_currentT;

81: float g_terminatePointMax;

82:

83: out vec4 fragOutput0;

84:

85:

86: uniform sampler3D in_volume[1];

87: uniform vec4 in_volume_scale[1];

88: uniform vec4 in_volume_bias[1];

89: uniform int in_noOfComponents;

90: uniform int in_independentComponents;

91:

92: uniform sampler2D in_noiseSampler;

93: #ifndef GL_ES

94: uniform sampler2D in_depthSampler;

95: #endif

96:

97: // Camera position

98: uniform vec3 in_cameraPos;

99: uniform mat4 in_volumeMatrix[1];

100: uniform mat4 in_inverseVolumeMatrix[1];

101: uniform mat4 in_textureDatasetMatrix[1];

102: uniform mat4 in_inverseTextureDatasetMatrix[1];

103: uniform mat4 in_textureToEye[1];

104: uniform vec3 in_texMin[1];

105: uniform vec3 in_texMax[1];

106: uniform mat4 in_cellToPoint[1];

107: // view and model matrices

108: uniform mat4 in_projectionMatrix;

109: uniform mat4 in_inverseProjectionMatrix;

110: uniform mat4 in_modelViewMatrix;

111: uniform mat4 in_inverseModelViewMatrix;

112: varying mat4 ip_inverseTextureDataAdjusted;

113:

114: // Ray step size

115: uniform vec3 in_cellStep[1];

116: uniform vec2 in_scalarsRange[4];

117: uniform vec3 in_cellSpacing[1];

118:

119: // Sample distance

120: uniform float in_sampleDistance;

121:

122: // Scales

123: uniform vec2 in_windowLowerLeftCorner;

124: uniform vec2 in_inverseOriginalWindowSize;

125: uniform vec2 in_inverseWindowSize;

126: uniform vec3 in_textureExtentsMax;

127: uniform vec3 in_textureExtentsMin;

128:

129: // Material and lighting

130: uniform vec3 in_diffuse[4];

131: uniform vec3 in_ambient[4];

132: uniform vec3 in_specular[4];

133: uniform float in_shininess[4];

134:

135: // Others

136: uniform bool in_useJittering;

137: vec3 g_rayJitter = vec3(0.0);

138:

139: uniform vec2 in_averageIPRange;

140: uniform vec3 in_lightAmbientColor[1];

141: uniform vec3 in_lightDiffuseColor[1];

142: uniform vec3 in_lightSpecularColor[1];

143: vec4 g_lightPosObj;

144: vec3 g_ldir;

145: vec3 g_vdir;

146: vec3 g_h;

147:

148:

149:

150: const float g_opacityThreshold = 1.0 - 1.0 / 255.0;

151:

152:

153:

154:

155: int clippingPlanesSize;

156: vec3 objRayDir;

157: mat4 textureToObjMat;

158:

159:

160:

161:

162:

163:

164:

165: //VTK::GradientCache::Dec

166:

167: //VTK::Transfer2D::Dec

168:

169: uniform sampler2D in_opacityTransferFunc_0[1];

170:

171: float computeOpacity(vec4 scalar)

172: {

173: return texture2D(in_opacityTransferFunc_0[0], vec2(scalar.w, 0)).r;

174: }

175:

176: vec4 computeGradient(in vec3 texPos, in int c, in sampler3D volume, in int index)

177: {

178: return vec4(0.0);

179: }

180:

181:

182: uniform sampler2D [1];

183:

184:

185:

186: vec4 computeLighting(vec4 color, int component)

187: {

188: vec4 finalColor = vec4(0.0);

189: finalColor = vec4(color.rgb, 0.0);

190: finalColor.a = color.a;

191: return finalColor;

192: }

193:

194: uniform sampler2D in_colorTransferFunc_0[1];

195:

196: vec4 computeColor(vec4 scalar, float opacity)

197: {

198: return computeLighting(vec4(texture2D(in_colorTransferFunc_0[0],

199: vec2(scalar.w, 0.0)).xyz, opacity), 0);

200: }

201:

202:

203: vec3 computeRayDirection()

204: {

205: return normalize(ip_vertexPos.xyz - g_eyePosObj.xyz);

206: }

207:

208: //VTK::Picking::Dec

209:

210: //VTK::RenderToImage::Dec

211:

212: //VTK::DepthPeeling::Dec

213:

214: /// We support only 8 clipping planes for now

215: /// The first value is the size of the data array for clipping

216: /// planes (origin, normal)

217: uniform float in_clippingPlanes[49];

218: uniform float in_scale;

219: uniform float in_bias;

220:

221: //////////////////////////////////////////////////////////////////////////////

222: ///

223: /// Helper functions

224: ///

225: //////////////////////////////////////////////////////////////////////////////

226:

227: /**

228: * Transform window coordinate to NDC.

229: */

230: vec4 WindowToNDC(const float xCoord, const float yCoord, const float zCoord)

231: {

232: vec4 NDCCoord = vec4(0.0, 0.0, 0.0, 1.0);

233:

234: NDCCoord.x = (xCoord - in_windowLowerLeftCorner.x) * 2.0 *

235: in_inverseWindowSize.x - 1.0;

236: NDCCoord.y = (yCoord - in_windowLowerLeftCorner.y) * 2.0 *

237: in_inverseWindowSize.y - 1.0;

238: NDCCoord.z = (2.0 * zCoord - (gl_DepthRange.near + gl_DepthRange.far)) /

239: gl_DepthRange.diff;

240:

241: return NDCCoord;

242: }

243:

244: /**

245: * Transform NDC coordinate to window coordinates.

246: */

247: vec4 NDCToWindow(const float xNDC, const float yNDC, const float zNDC)

248: {

249: vec4 WinCoord = vec4(0.0, 0.0, 0.0, 1.0);

250:

251: WinCoord.x = (xNDC + 1.f) / (2.f * in_inverseWindowSize.x) +

252: in_windowLowerLeftCorner.x;

253: WinCoord.y = (yNDC + 1.f) / (2.f * in_inverseWindowSize.y) +

254: in_windowLowerLeftCorner.y;

255: WinCoord.z = (zNDC * gl_DepthRange.diff +

256: (gl_DepthRange.near + gl_DepthRange.far)) / 2.f;

257:

258: return WinCoord;

259: }

260:

261: //////////////////////////////////////////////////////////////////////////////

262: ///

263: /// Ray-casting

264: ///

265: //////////////////////////////////////////////////////////////////////////////

266:

267: /**

268: * Global initialization. This method should only be called once per shader

269: * invocation regardless of whether castRay() is called several times (e.g.

270: * vtkDualDepthPeelingPass). Any castRay() specific initialization should be

271: * placed within that function.

272: */

273: void initializeRayCast()

274: {

275: /// Initialize g_fragColor (output) to 0

276: g_fragColor = vec4(0.0);

277: g_dirStep = vec3(0.0);

278: g_srcColor = vec4(0.0);

279: g_exit = false;

280:

281:

282: // Get the 3D texture coordinates for lookup into the in_volume dataset

283: g_dataPos = ip_textureCoords.xyz;

284:

285: // Eye position in dataset space

286: g_eyePosObj = in_inverseVolumeMatrix[0] * vec4(in_cameraPos, 1.0);

287:

288: // Getting the ray marching direction (in dataset space);

289: vec3 rayDir = computeRayDirection();

290:

291: // Multiply the raymarching direction with the step size to get the

292: // sub-step size we need to take at each raymarching step

293: g_dirStep = (ip_inverseTextureDataAdjusted *

294: vec4(rayDir, 0.0)).xyz * in_sampleDistance;

295:

296: // 2D Texture fragment coordinates [0,1] from fragment coordinates.

297: // The frame buffer texture has the size of the plain buffer but

298: // we use a fraction of it. The texture coordinate is less than 1 if

299: // the reduction factor is less than 1.

300: // Device coordinates are between -1 and 1. We need texture

301: // coordinates between 0 and 1. The in_noiseSampler and in_depthSampler

302: // buffers have the original size buffer.

303: vec2 fragTexCoord = (gl_FragCoord.xy - in_windowLowerLeftCorner) *

304: in_inverseWindowSize;

305:

306: if (in_useJittering)

307: {

308: float jitterValue = texture2D(in_noiseSampler, fragTexCoord).x;

309: g_rayJitter = g_dirStep * jitterValue;

310: g_dataPos += g_rayJitter;

311: }

312: else

313: {

314: g_dataPos += g_dirStep;

315: }

316:

317: // Flag to deternmine if voxel should be considered for the rendering

318: g_skip = false;

319:

320:

321: // Flag to indicate if the raymarch loop should terminate

322: bool stop = false;

323:

324: g_terminatePointMax = 0.0;

325:

326: #ifdef GL_ES

327: vec4 l_depthValue = vec4(1.0,1.0,1.0,1.0);

328: #else

329: vec4 l_depthValue = texture2D(in_depthSampler, fragTexCoord);

330: #endif

331: // Depth test

332: if(gl_FragCoord.z >= l_depthValue.x)

333: {

334: discard;

335: }

336:

337: // color buffer or max scalar buffer have a reduced size.

338: fragTexCoord = (gl_FragCoord.xy - in_windowLowerLeftCorner) *

339: in_inverseOriginalWindowSize;

340:

341: // Compute max number of iterations it will take before we hit

342: // the termination point

343:

344: // Abscissa of the point on the depth buffer along the ray.

345: // point in texture coordinates

346: vec4 terminatePoint = WindowToNDC(gl_FragCoord.x, gl_FragCoord.y, l_depthValue.x);

347:

348: // From normalized device coordinates to eye coordinates.

349: // in_projectionMatrix is inversed because of way VT

350: // From eye coordinates to texture coordinates

351: terminatePoint = ip_inverseTextureDataAdjusted *

352: in_inverseVolumeMatrix[0] *

353: in_inverseModelViewMatrix *

354: in_inverseProjectionMatrix *

355: terminatePoint;

356: terminatePoint /= terminatePoint.w;

357:

358: g_terminatePointMax = length(terminatePoint.xyz - g_dataPos.xyz) /

359: length(g_dirStep);

360: g_currentT = 0.0;

361:

362:

363:

364:

365:

366: //VTK::RenderToImage::Init

367:

368: //VTK::DepthPass::Init

369: }

370:

371: /**

372: * March along the ray direction sampling the volume texture. This function

373: * takes a start and end point as arguments but it is up to the specific render

374: * pass implementation to use these values (e.g. vtkDualDepthPeelingPass). The

375: * mapper does not use these values by default, instead it uses the number of

376: * steps defined by g_terminatePointMax.

377: */

378: vec4 castRay(const float zStart, const float zEnd)

379: {

380: //VTK::DepthPeeling::Ray::Init

381:

382: //VTK::DepthPeeling::Ray::PathCheck

383:

384:

385:

386: /// For all samples along the ray

387: while (!g_exit)

388: {

389:

390: g_skip = false;

391:

392:

393:

394:

395:

396:

397:

398:

399:

400: //VTK::PreComputeGradients::Impl

401:

402:

403: if (!g_skip)

404: {

405: vec4 scalar = texture3D(in_volume[0], g_dataPos);

406: scalar.r = scalar.r * in_volume_scale[0].r + in_volume_bias[0].r;

407: scalar = vec4(scalar.r);

408: g_srcColor = vec4(0.0);

409: g_srcColor.a = computeOpacity(scalar);

410: if (g_srcColor.a > 0.0)

411: {

412: g_srcColor = computeColor(scalar, g_srcColor.a);

413: // Opacity calculation using compositing:

414: // Here we use front to back compositing scheme whereby

415: // the current sample value is multiplied to the

416: // currently accumulated alpha and then this product

417: // is subtracted from the sample value to get the

418: // alpha from the previous steps. Next, this alpha is

419: // multiplied with the current sample colour

420: // and accumulated to the composited colour. The alpha

421: // value from the previous steps is then accumulated

422: // to the composited colour alpha.

423: g_srcColor.rgb *= g_srcColor.a;

424: g_fragColor = (1.0f - g_fragColor.a) * g_srcColor + g_fragColor;

425: }

426: }

427:

428: //VTK::RenderToImage::Impl

429:

430: //VTK::DepthPass::Impl

431:

432: /// Advance ray

433: g_dataPos += g_dirStep;

434:

435:

436: if(any(greaterThan(g_dataPos, in_texMax[0])) ||

437: any(lessThan(g_dataPos, in_texMin[0])))

438: {

439: break;

440: }

441:

442: // Early ray termination

443: // if the currently composited colour alpha is already fully saturated

444: // we terminated the loop or if we have hit an obstacle in the

445: // direction of they ray (using depth buffer) we terminate as well.

446: if((g_fragColor.a > g_opacityThreshold) ||

447: g_currentT >= g_terminatePointMax)

448: {

449: break;

450: }

451: ++g_currentT;

452: }

453:

454:

455:

456: return g_fragColor;

457: }

458:

459: /**

460: * Finalize specific modes and set output data.

461: */

462: void finalizeRayCast()

463: {

464:

465:

466:

467:

468:

469:

470:

471:

472:

473: // Special coloring mode which renders the voxel index in fragments that

474: // have accumulated certain level of opacity. Used during the selection

475: // pass vtkHardwareSelection::ID_MID24.

476: if (g_fragColor.a > 3.0/ 255.0)

477: {

478: uvec3 volumeDim = uvec3(in_textureExtentsMax - in_textureExtentsMin);

479: uvec3 voxelCoords = uvec3(volumeDim * g_dataPos);

480: // vtkHardwareSelector assumes index 0 to be empty space, so add uint(1).

481: uint idx = volumeDim.x * volumeDim.y * voxelCoords.z +

482: volumeDim.x * voxelCoords.y + voxelCoords.x + uint(1);

483: idx = ((idx & 0xff000000) >> 24);

484: fragOutput0 = vec4(float(idx % uint(256)) / 255.0,

485: float((idx / uint(256)) % uint(256)) / 255.0,

486: float(idx / uint(65536)) / 255.0, 1.0);

487: }

488: else

489: {

490: fragOutput0 = vec4(0.0);

491: }

492: return;

493:

494: g_fragColor.r = g_fragColor.r * in_scale + in_bias * g_fragColor.a;

495: g_fragColor.g = g_fragColor.g * in_scale + in_bias * g_fragColor.a;

496: g_fragColor.b = g_fragColor.b * in_scale + in_bias * g_fragColor.a;

497: fragOutput0 = g_fragColor;

498:

499: //VTK::RenderToImage::Exit

500:

501: //VTK::DepthPass::Exit

502: }

503:

504: //////////////////////////////////////////////////////////////////////////////

505: ///

506: /// Main

507: ///

508: //////////////////////////////////////////////////////////////////////////////

509: void main()

510: {

511:

512: initializeRayCast();

513: castRay(-1.0, -1.0);

514: finalizeRayCast();

515: }



ERROR: In /Users/kitware/dashboards/buildbot-slave/8275bd07/build/superbuild/paraview/src/VTK/Rendering/OpenGL2/vtkShaderProgram.cxx, line 446

vtkShaderProgram (0x60c00058d5b0): ERROR: 0:483: '&' does not operate on 'unsigned int' and 'int'



ERROR: In /Users/kitware/dashboards/buildbot-slave/8275bd07/build/superbuild/paraview/src/VTK/Rendering/VolumeOpenGL2/vtkOpenGLGPUVolumeRayCastMapper.cxx, line 3169

vtkOpenGLGPUVolumeRayCastMapper (0x7fc085e21f60): Shader failed to compile


Traceback (most recent call last):

File "<string>", line 450, in <module>

AttributeError: 'vtkCommonDataModelPython.vtkImageData' object has no attribute 'GetPoints'




2018-07-11 21:08 GMT+07:00 Aron Helser <[hidden email]>:
Adding back the mailing list....

Alexey,
Do you have a particular goal, or do you just want to try out vtk-js? If you just want to see what it can do, it is used the rendering in ParaView Glance, which you can try out here:
It will load several different data formats, or just start with the example datasets. As you can see, vtk-js is used for real and useful projects.

For just VTK-js, the example applications like the OBJ viewer: https://kitware.github.io/vtk-js/examples/OBJViewer.html
are a good starting point - there are several that will load different formats of data.

The script I pointed you at is a ParaView macro, which means that after running the ParaView application, you add it by going to the Macro menu and choosing 'Add new macro...'

Regards,
Aron

On Wed, Jul 11, 2018 at 9:59 AM Alexey Pechnikov <[hidden email]> wrote:
Aron,

That script doesn't work in python2/python3 (there is no paraview extension) and it doesn't work in internal Paraview Python shell. Maybe do you know some working way? Or do you mean I need to write my own script using this one instead of normal documentation? Is vtk-js used by somebody or it's only just to fun unuseful project? Maybe I don't need to try it actually.

2018-07-11 20:16 GMT+07:00 Aron Helser <[hidden email]>:
Hi Alexey,
references this macro from vtk-js: Utilities/ParaView/export-scene-macro.py
It can be used to export a scene from ParaView for consumption by vtk-js. 

I know there are other ways to do it as well, but that was the easiest.
HTH,
Aron

On Wed, Jul 11, 2018 at 5:54 AM Alexey Pechnikov <[hidden email]> wrote:
Hi,

I couldn't find any documentation or tool to do it. Google doesn't know anything about "vti-web" data format. VTK/VTI and other VTK formats are not allowed I see. Is disassembling example datasets and build own tools the only possible way?!

--
Best regards, Alexey Pechnikov.
_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers



--
Best regards, Alexey Pechnikov.



--
Best regards, Alexey Pechnikov.
_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers

_______________________________________________
Powered by www.kitware.com

Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html

Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ

Search the list archives at: http://markmail.org/search/?q=vtkusers

Follow this link to subscribe/unsubscribe:
https://public.kitware.com/mailman/listinfo/vtkusers