Sergei Klimkin, Head of C3D Web Vision Development Team at C3D Labs, explains how the developers of C3D Web Vision, a browser-based 3D visualization tool, refine the solution based on customer feedback.
The C3D Web Vision team at C3D Labs is developing a browser-embedded solution. It visualizes 3D models and scenes, both simple and complicated. The solution supports wireframe and shaded representations. C3D Web Vision also offers a camera pan/rotate/zoom capability. Users can add dimensions and other annotations. Besides, C3D Web Vision supports geometry color configuration, visibility, and other object properties.
Fig. 1
The solution consists of two tiers. The first is the frontend, the embedded npm module which serves as a WebGL canvas. The second is the server, a microservice embedded in the microservice architecture. It manages data, loads models design trees, merges them, etc.
Let me tell you about the new functionality we’ve developed in 2024, the performance improvements, and the customer-suggested features. In many cases, we are not only following our roadmap but also supporting customized solutions. Then, I will share our plans for 2025.
Fig. 2
At C3Days 2023, we announced new measurement features. And we’ve delivered them! We’ve added a measurement function for 2D objects. Now you can measure linear dimensions between flat geometric objects. The users mostly send us B-rep models (recently, we’ve been getting more polygonal models with triangulated meshes). Therefore, we tried to learn how to analyze the geometry and identify flat objects to measure the distance and angle between them.
Fig. 3
Then, we added an object to measure radii. It is easy to measure the radius of a simple cylindrical surface.
Fig. 4
Mesh geometry provides no math definition of its underlying surface. To solve this problem, we have added the ability to snap a point to a mesh. If some geometry cannot be recognized, as measurement, we can snap a dimension to the mesh points. It was suggested by our users who needed to snap dimensions to a mesh. They asked us, and we proposed a solution: snap-to-mesh points.
Fig. 5
BIM users have specific requirements for navigating large models (such as factories). As C3D Labs solutions were originally developed primarily for manufacturing, camera orbit, and zoom capabilities did not always match the BIM use cases, especially when the model was large. We’ve improved the zoom feature: it not only changes the scale but also pans the camera to the object under the pointer. This has improved one of the key user scenarios: navigating the model with the zoom feature has become much more convenient and efficient.
Fig. 6
We’ve added another function: rotation around the up-vector. Orbiting the camera usually flipped the model, which was rather inconvenient for BIM applications. To solve this, we added rotation about a user-provided axis (x, y, or z). Besides that, a model can be rotated around a selected tangency point. The user chooses the point, and the model rotates about it rather than the camera’s focal point. Now we have a target, a tangency point on the model for better camera control.
Fig. 7
There was another BIM-related issue. The converter creates visualization-ready models. For example, a ladder would consist of multiple bodies. The design tree ends up with a lot of extra components. It is not easy to determine if the user needs all of them or not. Sometimes such multiple components are added for better rendering only. In this example, the user expects to select the entire ladder, but each step is selected separately, which is not what they need. Now we check the body attributes during conversion. If a body has no attributes at all, it is grouped with its parent. To separate the bodies, they must have some attributes, at least an identifier.
Besides new functionality, we are improving on performance. There has been a noticeable increase in requests for very large model visualization.
Consider an example. Suppose our project is amazingly huge. It is an enormous factory with about 10 million components. It means 210 million triangles and 20-25 GB file size. If that was not enough, the customer requested at least 30 FPS. And we did this--we visualized the model.
Even early C3D Web Vision versions supported partial model loading. A massive model is loaded in chunks while some small objects can be omitted. We have redefined this process. Moreover, we have moved to WebGL 2.0 to get more performance improvement opportunities. To speed up model loading, we’ve introduced local cache. In this way, there are no continuous requests to the server as the user navigates the massive factory model back and forth. However, there are limitations: it works with HTTPS only, not HTTP. To quickly load the model, visualize, and navigate it, in this view, to understand how it looks, to quickly start navigating through it, we added levels of detail (LOD). An LOD applies to a region, not to a particular geometry. Suppose a model fragment contains 50,000 objects. We analyze it and select an appropriate LOD to convert the huge fragment into 5 MB for quick load. Later, when the user zooms in, a more detailed model is loaded.
This is an alpha version available for testing right now. We use it for process refinement, debugging, and fixing any functionality damaged at the optimization stage.
We always focus on user requests. Users apply to the Service Desk asking to slightly expand or adjust the product options. For example, they need better visualization to showcase their projects to customers.
Fig. 8
Let me tell you about a rather simple request. Initially, we generated a design tree from the parent node to the children. We could generate the complete tree, or limit the level of nesting. Such a limitation can be applied if the tree with all its properties and attributes is huge. The user requested to generate a “reverse tree”: from children to parents. We have added such a feature. Check the Show in the Tree function in the demo application. We can get all the parents of a 3D object and build the entire chain in the tree.
Fig. 9
Our users also asked to expand the annotation options. They wanted points instead of arrows, new line end styles, and crossed lines. They also wanted to configure the text outline, add an underline style, etc. Another request was to automatically shift the text left-to-right to match the movement of the camera and to pin the text. We’ve implemented all this.
Fig. 10
To improve continuous integration (CI), we have created repositories with RPM and DEB packages to make C3D Web Vision easy to install on common Linux distributions. We’ve also added a mirror for the npm registry. You can request this resource through our Service Desk.
Now it is time to share our immediate and more distant plans.
Fig. 11
First, we are going to introduce a human-readable Change log. We’ve considered the user requests, had some discussions, and concluded that the Change log could be integrated into the product documentation. It would be available in all versions, embedded, and linked to the text and images. It is a gracious solution, and, basically, it already works. The only thing left to add is auto-deployment on the site.
Another functionality essential to the BIM industry is the fly mode similar to a first-person video game. We’ve almost completed it. Still need to add settings and assign hotkeys. The fly mode is ready: the user can fly inside the buildings.
At C3Days 2023, I talked about the coming frame zoom feature. We managed to do it. Now we are adding animations. We expect the frame zoom to be available in the next release.
We also wanted to add handles to edit dynamic cross-sections. This is also almost completed: you can rotate and move the section plane interactively.
Another small new feature is the bounding box. We had doubts about it but concluded that the bounding box was necessary.
Another user-requested feature was a dynamic section of selected objects with a bounding box. We’ve also added handles to rotate, move, and scale the bounding box.
In the future, we will improve the existing measurement objects, and introduce new ones. Measurements along a polyline, along axes, surface-to-point distance, finding the minimum distance, etc. are of special interest.
Fig. 12
We also have plans to import PMIs from third-party, KOMPAS, or C3D formats. The converter functionality for this is already available. We will add visualization and do some minor tweaks.
We also plan to introduce a view cube widget to navigate in 3D.
Users also asked for an example of the web-based Collision Detection feature. We have two options for this. One option is a simple, stand-alone example. For the second option, the cache should contain a very large number of entities predefined for the Collision Detection feature. We store all the bounding boxes and object positions. Therefore, we can just send these bounding boxes to Collision Detection. Stay tuned: we’ll let you know when we implement this with acceptable performance.
As to performance: we will improve stability and fix the remaining bugs. We are currently testing the new version on triangulated surfaces, but have not yet tried ByRef models where problems may arise.
We’ve tried other partial load technologies and managed to accelerate file opening without using gRPC. As a result, we’ve achieved a performance boost through a new approach and adding a dedicated thread. We plan to improve the dynamic rendering. When running out of memory, we want to complete object rendering without fully loading them. The objects would be completely loaded as required but not when the users navigate the model.
Sergei Klimkin,
Head of C3D Web Vision Development Team,
C3D Labs
