Use the PureWeb service APIs to remote 2D/3D visualizations and expose other service-side functionality to web and mobile clients. Service APIs are provided in C++, .Net and Java.

Use the PureWeb client APIs to display the streamed graphics and provide seamless access to the functionality exposed in your service application. Client APIs are provided in JavaScript (HTML5), Android and iOS.

Who Uses PureWeb?

Aqumin uses the PureWeb platform to provide visualizations of big-data financial analytics in real time over the web.
With PureWeb® Design, CAD users in geographically diverse locations can easily collaborate simultaneously on the same design.
ResolutionMD® uses PureWeb to enable radiologists to securely diagnose patients from their Android and iOS devices.
With PureWeb, applications built on the Unreal Engine can be deployed on the cloud and accessed from anywhere.
CyberSKA uses the PureWeb platform to allow radio astronomers around the world to view image data sets hundreds of gigabytes in size.
By deploying a PureWeb-enabled version of HueSpace to the AWS cloud, Hue gives its users instant access to terabytes of geophysical data.

Why PureWeb?

Graphically Intensive

Modern mobile processors are amazing, but for truly graphics-intensive applications, capable of rendering tens of millions of polygons in real time, a mobile processor just won't do the trick. The PureWeb SDK allows you to leverage server-grade hardware (CPU/GPU) to render to mobile devices and web browsers.

Big Data

If your application relies on real-time processing and interaction with large data sets (think giga, tera, and petabyte range), it's impractical, and in many cases impossible, to transfer that data to an end user device. With the PureWeb SDK, only images of the rendered final product are streamed to your clients, keeping data transfer to a minimum.

High Security

Many applications rely on data that you don't want lingering on user devices (healthcare, financial, or trade secrets). With the PureWeb SDK, the data powering your application never leaves the data centre, and none of the rendered images are stored on end-user devices.

PureWeb in a Nutshell

The example below shows the minimal additions necessary to get a view out of your service application and displaying in an HTML5 client. PureWeb supports multiple graphical toolkits, this example assumes you have an OpenGL C++ application. Please checkout the samples or our documentation for more detail on how to get started.

myApp.cpp

using namespace CSI;
using namespace CSI::PureWeb;
using namespace CSI::PureWeb::Server;

MyApp::MyApp(){    
  m_pServer = new CSI::PureWeb::Server::StateManagerServer();
  m_pStateManager = new CSI::PureWeb::Server::StateManager("myPureWebApp");
  m_pServer->Start(m_pStateManager.get());  
  MyApp::StateManager().ViewManager().RegisterView("myViewName", this);
}

MyApp::~MyApp(){
  m_pServer->Stop();
  CSI::Library::Uninitialize();
}

Size MyApp::GetActualSize(){
  CSI::PureWeb::Size sz = Size(m_windowWidth, m_windowHeight);
  return sz;
}

void MyApp::RenderView(PureWeb::Server::RenderTarget target){
  glReadBuffer(GL_BACK);
  glPixelStorei(GL_PACK_ALIGNMENT, 4);
  glReadPixels(0, 0, m_windowWidth, m_windowWidth, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)target.RenderTargetImage().ImageBytes().begin());    
}

void MyApp::SetClientSize(Size clientSize){}
void MyApp::PostKeyEvent(const Ui::PureWebKeyboardEventArgs& keyEvent){}
void MyApp::PostMouseEvent(const Ui::PureWebMouseEventArgs& mouseEvent){}
myApp.h

#include "pureweb.h"
class MyApp : public CSI::PureWeb::Server::IRenderedView
{
  public:
    CSI::CountedPtr m_pServer;
    CSI::CountedPtr m_pStateManager;
    static CSI::PureWeb::Server::StateManager& StateManager(){
        return *CSI::PureWeb::Server::StateManager::Instance();
    }    
    void SetClientSize(CSI::PureWeb::Size clientSize);
    CSI::PureWeb::Size GetActualSize();
    void RenderView(CSI::PureWeb::Server::RenderTarget target);
    void PostKeyEvent(const CSI::PureWeb::Ui::PureWebKeyboardEventArgs& keyEvent);
    void PostMouseEvent(const CSI::PureWeb::Ui::PureWebMouseEventArgs& mouseEvent);    
  
  private:
    int m_windowWidth;
    int m_windowHeight;
};

client.html

<!DOCTYPE html>
<html>
    <head>
        <script src="pureweb.min.js"></script> 
        <script src="client.js"></script> 
        <link rel="stylesheet" href="client.css"> 
    </head>
    <body onLoad="start();">        
        <div id="myViewId" class="purewebview"></div>
    </body>
</html>
client.css

body{    
  overflow: hidden;
}

#myViewId{
  position:absolute;
  left:0px;
  right:0px;
  top:0px; 
  bottom: 0px;    
}
client.js

var myView = null;
start = function() {    
    myView = new pureweb.client.View({id: 'myViewId', viewName: 'myViewName'});      
    pureweb.connect(location.href);
}

The PureWeb Advantage

Lightweight and Easy to Integrate

The core APIs consist of a small collection of methods and interfaces that use the native building blocks of your chosen development platform, yet remain largely independent of the application logic, making the SDK both lightweight and easy to integrate. Service APIs are available in C++, .Net and Java, and clients APIs are available for HTML5, iOS, and Android.

Optimized for Performance

The PureWeb SDK is designed to provide the highest level of performance, so that users on personal devices can interact with your 3D graphics seamlessly. The built-in flow control and robust low-latency imaging pipeline ensure that your application will make the best out of even the most challenging network conditions. Support for a variety of image formats and encoding qualities ensures that you can fine-tune performance at a granular level.

Focused on the User Experience

The client applications are lightweight interfaces which you build with the native building blocks that you’re already familiar with. This gives you full control over the client’s look, feel, and feature set, and offers a superior user experience when compared to screen scraping and VDI solutions. For users of HTML5 clients, there are no cumbersome downloads or plug-ins to deal with, since the client runs natively in the browser.

Versatile and Flexible

Application development is not one-size-fits-all, and we give you options where it matters. You can expose as much or as little of the service-side functionality as needed, as well as expose different features on different platforms. This can open up applications to new workflows and new users. And we don't tie you down to a specific deployment model: deploy on-premise, to a private cloud or to a public cloud such as Amazon Web Services.

Synchronous Real-Time Collaboration

The PureWeb SDK provides APIs for synchronous real-time collaboration, allowing multiple users to interact simultaneously with the same application session, each from their own client device. This opens up new possibilities for peer consultation, tele-maintenance, and offsite training. Enhance the collaboration experience with the built-in image annotation and resource management tools.

Single Code Base

When developing with the PureWeb SDK, you write the core functionality and rendering logic only once, or leverage an existing application where this has already been done. You then add a thin layer of API calls that allow your web or mobile client(s) to tap into this logic. This makes it possible to support a broad range of end user devices from a single code base, and it provides an efficient way to keep up with the fast pace of new devices.


Calgary Scientific | Documentation | Download | Contact Us | Legal Statements

© 2015 - 2016 Calgary Scientific Inc.