@geode/opengeodeweb-front 9.12.0 → 9.12.1-rc.1

package/tests/integration/setup.js

@@ -0,0 +1,111 @@
+// Node.js imports
+import path from "path"
+import { v4 as uuidv4 } from "uuid"
+import { WebSocket } from "ws"
+
+// Third party imports
+import { setActivePinia } from "pinia"
+import { createTestingPinia } from "@pinia/testing"
+import { afterAll, beforeAll, expect, vi } from "vitest"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+
+// Local imports
+import { useDataStyleStore } from "~/stores/data_style"
+import { useDataBaseStore } from "~/stores/data_base"
+import { useGeodeStore } from "~/stores/geode"
+import { useViewerStore } from "~/stores/viewer"
+import { useInfraStore } from "~/stores/infra"
+import { api_fetch } from "~/composables/api_fetch"
+import { appMode } from "~/utils/app_mode"
+import Status from "~/utils/status"
+import {
+  executable_name,
+  executable_path,
+  run_back,
+  run_viewer,
+} from "~/utils/local"
+import { getCurrentFolders, cleanupCreatedFolders } from "./utils.js"
+
+async function setupIntegrationTests(file_name, geode_object, object_type) {
+  const pinia = createTestingPinia({
+    stubActions: false,
+    createSpy: vi.fn,
+  })
+  setActivePinia(pinia)
+  const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
+  const geodeStore = useGeodeStore()
+  const viewerStore = useViewerStore()
+  const infraStore = useInfraStore()
+  infraStore.app_mode = appMode.BROWSER
+
+  const microservices_path = path.join("tests", "integration", "microservices")
+  const project_folder_path = path.join(__dirname, "data", uuidv4())
+  const upload_folder_path = path.join(__dirname, "data", "uploads")
+  const back_path = path.join(
+    executable_path(path.join(microservices_path, "back")),
+    executable_name("opengeodeweb-back"),
+  )
+  const viewer_path = path.join(
+    executable_path(path.join(microservices_path, "viewer")),
+    executable_name("opengeodeweb-viewer"),
+  )
+  const [back_port, viewer_port] = await Promise.all([
+    run_back(back_path, {
+      project_folder_path: project_folder_path,
+      upload_folder_path: upload_folder_path,
+    }),
+    run_viewer(viewer_path, {
+      project_folder_path: project_folder_path,
+    }),
+  ])
+  console.log("back_port", back_port)
+  console.log("viewer_port", viewer_port)
+  geodeStore.default_local_port = back_port
+  viewerStore.default_local_port = viewer_port
+  await viewerStore.ws_connect()
+
+  const response = await api_fetch({
+    schema: back_schemas.opengeodeweb_back.save_viewable_file,
+    params: {
+      input_geode_object: geode_object,
+      filename: file_name,
+    },
+  })
+
+  const id = response.data._value.id
+  await dataBaseStore.registerObject(id)
+  await dataStyleStore.addDataStyle(id, geode_object, object_type)
+  expect(viewerStore.status).toBe(Status.CONNECTED)
+  return { id, back_port, viewer_port }
+}
+
+const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
+  return callback({ name })
+})
+
+vi.stubGlobal("navigator", {
+  ...navigator,
+  locks: {
+    request: mockLockRequest,
+  },
+})
+
+let foldersBeforeTests = new Set()
+
+const data_folder = path.join("tests", "integration", "data")
+beforeAll(() => {
+  global.WebSocket = WebSocket
+  foldersBeforeTests = getCurrentFolders(data_folder)
+  console.log("foldersBeforeTests", foldersBeforeTests)
+})
+
+afterAll(() => {
+  console.log("afterAll")
+  delete global.WebSocket
+  setTimeout(() => {
+    cleanupCreatedFolders(data_folder, foldersBeforeTests)
+  }, 2000)
+})
+
+export { setupIntegrationTests }

package/tests/integration/stores/data_style/mesh/edges.nuxt.test.js

@@ -0,0 +1,77 @@
+// Node.js imports
+
+// Third party imports
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
+let id, back_port, viewer_port
+const file_name = "test.og_edc2d"
+const geode_object = "EdgedCurve2D"
+const object_type = "mesh"
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
+    file_name,
+    geode_object,
+    object_type,
+  ))
+}, 20000)
+
+afterEach(async () => {
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+})
+
+describe("Mesh edges", () => {
+  describe("Edges visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      await dataStyleStore.setMeshEdgesVisibility(id, true)
+      expect(dataStyleStore.meshEdgesVisibility(id)).toBe(true)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+  describe("Edges active coloring", () => {
+    test("test coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = ["color"]
+      for (let i = 0; i < coloringTypes.length; i++) {
+        dataStyleStore.setMeshEdgesActiveColoring(id, coloringTypes[i])
+        expect(dataStyleStore.meshEdgesActiveColoring(id)).toBe(
+          coloringTypes[i],
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
+  })
+  describe("Edges color", () => {
+    test("test red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshEdgesColor(id, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_edges_schemas.color,
+          params: { id, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshEdgesColor(id)).toStrictEqual(color)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

package/tests/integration/stores/data_style/mesh/points.nuxt.test.js

@@ -0,0 +1,79 @@
+// Node.js imports
+
+// Third party imports
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
+let id, back_port, viewer_port
+const file_name = "test.og_edc2d"
+const geode_object = "EdgedCurve2D"
+const object_type = "mesh"
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
+    file_name,
+    geode_object,
+    object_type,
+  ))
+}, 20000)
+
+afterEach(async () => {
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+})
+
+describe("Mesh points", () => {
+  describe("Points visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      await dataStyleStore.setMeshPointsVisibility(id, true)
+      expect(dataStyleStore.meshPointsVisibility(id)).toBe(true)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Points active coloring", () => {
+    test("test coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = ["color"]
+      for (let i = 0; i < coloringTypes.length; i++) {
+        dataStyleStore.setMeshPointsActiveColoring(id, coloringTypes[i])
+        expect(dataStyleStore.meshPointsActiveColoring(id)).toBe(
+          coloringTypes[i],
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
+  })
+  describe("Points color", () => {
+    test("test red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPointsColor(id, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_points_schemas.color,
+          params: { id, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPointsColor(id)).toStrictEqual(color)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

package/tests/integration/stores/data_style/mesh/polygons.nuxt.test.js

@@ -0,0 +1,78 @@
+// Node.js imports
+
+// Third party imports
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
+let id, back_port, viewer_port
+const file_name = "test.og_psf3d"
+const geode_object = "PolygonalSurface3D"
+const object_type = "mesh"
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
+    file_name,
+    geode_object,
+    object_type,
+  ))
+}, 20000)
+
+afterEach(async () => {
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+})
+
+describe("Mesh polygons", () => {
+  describe("Polygons visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      await dataStyleStore.setMeshPolygonsVisibility(id, true)
+      expect(dataStyleStore.meshPolygonsVisibility(id)).toBe(true)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+  describe("Polygons active coloring", () => {
+    test("test coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = ["color"]
+      for (let i = 0; i < coloringTypes.length; i++) {
+        dataStyleStore.setMeshPolygonsActiveColoring(id, coloringTypes[i])
+        expect(dataStyleStore.meshPolygonsActiveColoring(id)).toBe(
+          coloringTypes[i],
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
+  })
+  describe("Polygons color", () => {
+    test("test red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPolygonsColor(id, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_polygons_schemas.color,
+          params: { id, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPolygonsColor(id)).toStrictEqual(color)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

package/tests/integration/stores/data_style/mesh/polyhedra.nuxt.test.js

@@ -0,0 +1,78 @@
+// Node.js imports
+
+// Third party imports
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
+let id, back_port, viewer_port
+const file_name = "test.og_rgd3d"
+const geode_object = "RegularGrid3D"
+const object_type = "mesh"
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
+    file_name,
+    geode_object,
+    object_type,
+  ))
+}, 20000)
+
+afterEach(async () => {
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+})
+
+describe("Mesh polyhedra", () => {
+  describe("Polyhedra visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      await dataStyleStore.setMeshPolyhedraVisibility(id, true)
+      expect(dataStyleStore.meshPolyhedraVisibility(id)).toBe(true)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+  describe("Polyhedra active coloring", () => {
+    test("test coloring", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const coloringTypes = ["color"]
+      for (let i = 0; i < coloringTypes.length; i++) {
+        dataStyleStore.setMeshPolyhedraActiveColoring(id, coloringTypes[i])
+        expect(dataStyleStore.meshPolyhedraActiveColoring(id)).toBe(
+          coloringTypes[i],
+        )
+        expect(viewerStore.status).toBe(Status.CONNECTED)
+      }
+    })
+  })
+  describe("Polyhedra color", () => {
+    test("test red", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const color = { r: 255, g: 0, b: 0 }
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshPolyhedraColor(id, color)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_polyhedra_schemas.color,
+          params: { id, color },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshPolyhedraColor(id)).toStrictEqual(color)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})

package/tests/integration/utils.js

@@ -0,0 +1,35 @@
+// Node.js imports
+import fs from "fs"
+import path from "path"
+
+function getCurrentFolders(dataFolderPath) {
+  if (!fs.existsSync(dataFolderPath)) {
+    return new Set()
+  }
+  const entries = fs.readdirSync(dataFolderPath)
+  const folders = new Set()
+  for (const entry of entries) {
+    const entryPath = path.join(dataFolderPath, entry)
+    if (fs.statSync(entryPath).isDirectory()) {
+      folders.add(entry)
+    }
+  }
+  return folders
+}
+
+function cleanupCreatedFolders(dataFolderPath, foldersBeforeTests) {
+  if (!fs.existsSync(dataFolderPath)) {
+    return
+  }
+  const currentFolders = getCurrentFolders(dataFolderPath)
+  console.log("getCurrentFolders currentFolders", currentFolders)
+  for (const folder of currentFolders) {
+    if (!foldersBeforeTests.has(folder)) {
+      const folderPath = path.join(dataFolderPath, folder)
+      fs.rmSync(folderPath, { recursive: true, force: true })
+      console.log(`Deleted folder: ${folderPath}`)
+    }
+  }
+}
+
+export { getCurrentFolders, cleanupCreatedFolders }

package/tests/unit/utils/validate_schema.nuxt.test.js

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "vitest"
 
-import validate_schema from "@ogw_f/utils/validate_schema.js"
-console.log("@ogw_f", "@ogw_f")
+import validate_schema from "~/utils/validate_schema.js"
 
 describe("validate_schema.js", () => {
   const schema = {

package/tests/vitest.config.js

@@ -20,6 +20,7 @@ export default defineConfig({
         test: {
           name: "integration",
           include: ["tests/integration/**/*.test.js"],
+          setupFiles: ["tests/integration/setup.js"],
           environment: "nuxt",
           server: {
             deps: {

package/utils/local.js

@@ -50,13 +50,11 @@ function create_path(path) {
   return path
 }
 
-async function get_available_port(port) {
-  const available_port = await getPort({
-    port,
+function get_available_port() {
+  return getPort({
     host: "localhost",
+    random: true,
   })
-  console.log("available_port", available_port)
-  return available_port
 }
 
 async function run_script(
@@ -69,6 +67,7 @@ async function run_script(
     setTimeout(() => {
       reject("Timed out after " + timeout_seconds + " seconds")
     }, timeout_seconds * 1000)
+
     const child = child_process.spawn(command, args, {
       encoding: "utf8",
       shell: true,
@@ -109,32 +108,43 @@ async function run_script(
   })
 }
 
-async function run_back(command, args = { port, data_folder_path }) {
+async function run_back(
+  command,
+  args = {
+    project_folder_path,
+    upload_folder_path: undefined,
+  },
+) {
   return new Promise(async (resolve, reject) => {
-    const back_port = await get_available_port(args.port)
-    const upload_folder_path = path.join(args.data_folder_path, "uploads")
+    let upload_folder_path = args.upload_folder_path
+    if (!args.upload_folder_path) {
+      upload_folder_path = args.project_folder_path
+    }
+    const port = await get_available_port()
     const back_args = [
-      "--port " + back_port,
-      "--data_folder_path " + args.data_folder_path,
+      "--port " + port,
+      "--data_folder_path " + args.project_folder_path,
       "--upload_folder_path " + upload_folder_path,
       "--allowed_origin http://localhost:*",
       "--timeout " + 0,
     ]
+    console.log("run_back", command, back_args)
     await run_script(command, back_args, "Serving Flask app")
-    resolve(back_port)
+    resolve(port)
   })
 }
 
-async function run_viewer(command, args = { port, data_folder_path }) {
+async function run_viewer(command, args = { project_folder_path }) {
   return new Promise(async (resolve, reject) => {
-    const viewer_port = await get_available_port(args.port)
+    const port = await get_available_port()
     const viewer_args = [
-      "--port " + viewer_port,
-      "--data_folder_path " + args.data_folder_path,
+      "--port " + port,
+      "--data_folder_path " + args.project_folder_path,
       "--timeout " + 0,
     ]
+    console.log("run_viewer", command, viewer_args)
     await run_script(command, viewer_args, "Starting factory")
-    resolve(viewer_port)
+    resolve(port)
   })
 }
 
@@ -153,8 +163,6 @@ function delete_folder_recursive(data_folder_path) {
 
 function kill_back(back_port) {
   return new Promise((resolve, reject) => {
-    console.log("back_schemas", back_schemas)
-
     fetch(
       "http://localhost:" +
         back_port +
@@ -176,7 +184,7 @@ function kill_back(back_port) {
 }
 
 function kill_viewer(viewer_port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     const socket = new WebSocket("ws://localhost:" + viewer_port + "/ws")
     socket.on("open", () => {
       console.log("Connected to WebSocket server")
@@ -191,19 +199,15 @@ function kill_viewer(viewer_port) {
     socket.on("message", (data) => {
       const message = data.toString()
       console.log("Received from server:", message)
+
       if (message.includes("hello")) {
-        try {
-          console.log("viewer_schemas", viewer_schemas)
-          socket.send(
-            JSON.stringify({
-              id: viewer_schemas.opengeodeweb_viewer.kill.$id,
-              method: viewer_schemas.opengeodeweb_viewer.kill.$id,
-            }),
-          )
-        } catch (error) {
-          console.error("WebSocket error:", error)
-          resolve()
-        }
+        socket.send(
+          JSON.stringify({
+            id: viewer_schemas.opengeodeweb_viewer.kill.$id,
+            method: viewer_schemas.opengeodeweb_viewer.kill.$id,
+          }),
+        )
+        resolve()
       }
     })
     socket.on("close", () => {
@@ -220,8 +224,8 @@ function kill_viewer(viewer_port) {
 async function run_browser(
   script_name,
   microservices_options = {
-    back: { command, args: { port: 5000, data_folder_path } },
-    viewer: { command, args: { port: 1234, data_folder_path } },
+    back: { command, args: { project_folder_path } },
+    viewer: { command, args: { project_folder_path } },
   },
 ) {
   console.log("microservices_options", microservices_options)
@@ -247,23 +251,16 @@ async function run_browser(
   process.env.BROWSER = true
   process.on("SIGINT", async () => {
     console.log("Shutting down microservices")
-    await Promise.all([
-      kill_back(process.env.GEODE_PORT),
-      kill_viewer(process.env.VIEWER_PORT),
-    ])
+    await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
     console.log("Quitting App...")
     process.exit(0)
   })
 
-  const nuxt_port = await get_available_port()
-  console.log("nuxt_port", nuxt_port)
-
-  process.env.NUXT_PORT = nuxt_port
   const nuxt_process = child_process.spawn("npm", ["run", script_name], {
     shell: true,
   })
 
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     nuxt_process.stdout.on("data", function (data) {
       const output = data.toString()
       const portMatch = output.match(
@@ -271,7 +268,9 @@ async function run_browser(
       )
       console.log("Nuxt: ", output)
       if (portMatch) {
-        resolve(portMatch[1])
+        const nuxt_port = portMatch[1]
+        process.env.NUXT_PORT = nuxt_port
+        resolve({ geode_port: back_port, viewer_port, nuxt_port })
         return
       }
     })

package/tests/integration/data/fake_id/edged_curve.vtp

@@ -1,20 +0,0 @@
-<?xml version="1.0"?>
-<VTKFile type="PolyData" version="1.0" byte_order="LittleEndian" header_type="UInt32" compressor="vtkZLibDataCompressor">
-	<PolyData>
-		<Piece NumberOfPoints="4" NumberOfLines="4">
-			<PointData>
-				<DataArray type="Float64" Name="points" format="ascii" NumberOfComponents="3" RangeMin="0.100000001" RangeMax="9.39999962">0.1 0.2 0.3 2.1 9.4 6.7 7.5 5.2 6.3 8.7 1.4 4.7 </DataArray>
-			</PointData>
-			<Points>
-				<DataArray type="Float64" Name="Points" format="ascii" NumberOfComponents="3" RangeMin="0.10000000000000001" RangeMax="9.4000000000000004">0.1 0.2 0.3 2.1 9.4 6.7 7.5 5.2 6.3 8.7 1.4 4.7 </DataArray>
-			</Points>
-			<CellData>
-				<DataArray type="Float64" Name="edges" format="ascii" NumberOfComponents="2" RangeMin="0" RangeMax="3">0 1 0 2 3 2 1 2 </DataArray>
-			</CellData>
-			<Lines>
-				<DataArray type="Int64" Name="connectivity" format="ascii" RangeMin="0" RangeMax="3">0 1 0 2 3 2 1 2 </DataArray>
-				<DataArray type="Int64" Name="offsets" format="ascii" RangeMin="0" RangeMax="4">2 4 6 8 </DataArray>
-			</Lines>
-		</Piece>
-	</PolyData>
-</VTKFile>