├── Simple ├── favicon.ico ├── README.md ├── simple_template.nmf ├── Makefile ├── index.html ├── example.js └── simple_template.cpp ├── Counter ├── counter.pexe ├── README.md ├── counter.nmf ├── counter.cpp ├── counter.hpp ├── index.html ├── instance_factory.hpp ├── counterView.js └── Makefile ├── ImageProc ├── mmcdonne.jpg ├── water_coins.jpg ├── smiley_200x200.png ├── image_proc.nmf ├── test │ ├── Makefile │ └── simpledom.cpp ├── face_detector.hpp ├── deploy ├── processor_id.cpp ├── processor.hpp ├── image_proc.hpp ├── processor_invert.cpp ├── processor_facedetect.hpp ├── instance_factory.hpp ├── processor_diff.cpp ├── test_processor.cpp ├── processor_redchannel.cpp ├── include │ ├── catch │ │ └── LICENSE_1_0.txt │ └── rapidjson │ │ ├── internal │ │ ├── swap.h │ │ ├── strfunc.h │ │ ├── ieee754.h │ │ ├── pow10.h │ │ ├── stack.h │ │ ├── meta.h │ │ ├── dtoa.h │ │ └── strtod.h │ │ ├── memorystream.h │ │ ├── memorybuffer.h │ │ ├── filereadstream.h │ │ ├── filewritestream.h │ │ ├── stringbuffer.h │ │ ├── error │ │ ├── en.h │ │ └── error.h │ │ ├── license.txt │ │ ├── prettywriter.h │ │ └── msinttypes │ │ └── inttypes.h ├── processor_pulsedetect.cpp ├── processor_gblur.cpp ├── processor_laplacian.cpp ├── index.html ├── Makefile ├── processor_cartoon.cpp ├── processor_skindetect.cpp ├── improc_instance.hpp ├── processor_probabilistichoughline.cpp ├── processor_smiley.cpp ├── test_display.cpp ├── processor_houghline.cpp ├── singleton_factory.hpp ├── processor_sobel.cpp ├── processor_barcode.cpp ├── README.md ├── url_loader_handler.hpp ├── video_img.js ├── image_proc.cpp ├── processor_watershed.cpp ├── video.js └── url_loader_handler.cpp ├── MonteCarlo ├── monte_carlo.pexe ├── monte_carlo.nmf ├── model_circle.cpp ├── model_parabola.cpp ├── README.md ├── test_mc.cpp ├── instance_factory.hpp ├── monte_carlo.hpp ├── index.html ├── d3 │ └── LICENSE ├── Makefile ├── mc_instance.hpp ├── singleton_factory.hpp ├── monte_carlo.cpp └── mcView.js ├── GettingStarted ├── hello_tutorial.pexe ├── hello_tutorial.nmf ├── README.md ├── Makefile ├── index.html └── hello_tutorial.cc ├── .gitignore ├── README.md └── setup.txt /Simple/favicon.ico: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Counter/counter.pexe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/Counter/counter.pexe -------------------------------------------------------------------------------- /ImageProc/mmcdonne.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/ImageProc/mmcdonne.jpg -------------------------------------------------------------------------------- /ImageProc/water_coins.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/ImageProc/water_coins.jpg -------------------------------------------------------------------------------- /MonteCarlo/monte_carlo.pexe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/MonteCarlo/monte_carlo.pexe -------------------------------------------------------------------------------- /Counter/README.md: -------------------------------------------------------------------------------- 1 | Counter 2 | ======= 3 | Example of transferring numeric data from javascript to NaCl. 4 | -------------------------------------------------------------------------------- /ImageProc/smiley_200x200.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/ImageProc/smiley_200x200.png -------------------------------------------------------------------------------- /GettingStarted/hello_tutorial.pexe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mattmcd/NaCl/HEAD/GettingStarted/hello_tutorial.pexe -------------------------------------------------------------------------------- /Counter/counter.nmf: -------------------------------------------------------------------------------- 1 | { "program" : 2 | { "portable" : 3 | { "pnacl-translate" : 4 | { "url" : "counter.pexe" 5 | } 6 | } 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Simple/README.md: -------------------------------------------------------------------------------- 1 | PPAPI Simple 2 | ============ 3 | The PPAPI Simple library in the NaCl SDK allows a simplified method of 4 | construction of the NaCl components. 5 | -------------------------------------------------------------------------------- /ImageProc/image_proc.nmf: -------------------------------------------------------------------------------- 1 | { "program" : 2 | { "portable" : 3 | { "pnacl-translate" : 4 | { "url" : "image_proc.pexe" 5 | } 6 | } 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /MonteCarlo/monte_carlo.nmf: -------------------------------------------------------------------------------- 1 | { "program" : 2 | { "portable" : 3 | { "pnacl-translate" : 4 | { "url" : "monte_carlo.pexe" 5 | } 6 | } 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Simple/simple_template.nmf: -------------------------------------------------------------------------------- 1 | { "program" : 2 | { "portable" : 3 | { "pnacl-translate" : 4 | { "url" : "simple_template.pexe" 5 | } 6 | } 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /GettingStarted/hello_tutorial.nmf: -------------------------------------------------------------------------------- 1 | { 2 | "program": { 3 | "portable": { 4 | "pnacl-translate": { 5 | "url": "hello_tutorial.pexe" 6 | } 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | 6 | # Compiled Dynamic libraries 7 | *.so 8 | *.dylib 9 | 10 | # Compiled Static libraries 11 | *.lai 12 | *.la 13 | *.a 14 | -------------------------------------------------------------------------------- /GettingStarted/README.md: -------------------------------------------------------------------------------- 1 | Getting Started 2 | =============== 3 | Getting Started example from Pepper 31. 4 | Includes the modifications described in the tutorial, plus use of 5 | some C++11 features. 6 | -------------------------------------------------------------------------------- /ImageProc/test/Makefile: -------------------------------------------------------------------------------- 1 | all: simpledom 2 | 3 | INCLUDE_DIR = /home/mattmcd/Work/Projects/NaCl/ImageProc/include 4 | 5 | simpledom: simpledom.cpp 6 | $(CXX) simpledom.cpp -o simpledom -I$(INCLUDE_DIR) 7 | -------------------------------------------------------------------------------- /MonteCarlo/model_circle.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | 3 | namespace { 4 | auto circleReg = ObjectRegister >("Circle", 5 | [](double x, double y){ return x*x + y*y < 1 ? 1 : 0; }); 6 | } 7 | 8 | -------------------------------------------------------------------------------- /MonteCarlo/model_parabola.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | 3 | namespace { 4 | auto parabolaReg = ObjectRegister >("Parabola", 5 | [](double x, double y){ return y < x*x ? 1 : 0; }); 6 | } 7 | 8 | -------------------------------------------------------------------------------- /MonteCarlo/README.md: -------------------------------------------------------------------------------- 1 | Monte Carlo 2 | =========== 3 | Monte Carlo simulation to estimate the volume of a region by generating 4 | points in unit square and estimating fraction in the region. 5 | 6 | [Try it out!](https://rawgithub.com/mattmcd/NaCl/master/MonteCarlo/index.html) 7 | -------------------------------------------------------------------------------- /ImageProc/face_detector.hpp: -------------------------------------------------------------------------------- 1 | #ifndef FACE_DETECTOR_HPP 2 | #define FACE_DETECTOR_HPP 3 | 4 | #include "processor.hpp" 5 | 6 | class FaceDetector : public Processor { 7 | public: 8 | virtual void detectFaces(const cv::Mat, std::vector&)=0; 9 | }; 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /ImageProc/deploy: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | sshfs $SERVER_ID:$SERVER_IMAGEPROC_LOC $SERVER_MOUNT 3 | echo Copying files to server 4 | cp $LOCAL_IMAGEPROC_LOC/{image_proc.pexe,image_proc.nmf,index.html,video.js,video_img.js,smiley_200x200.png} $SERVER_MOUNT 5 | echo Unmounting sshfs 6 | fusermount -u $SERVER_MOUNT 7 | -------------------------------------------------------------------------------- /ImageProc/processor_id.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | 3 | class IdentityProcessor : public Processor { 4 | public: 5 | cv::Mat operator()(cv::Mat); 6 | }; 7 | 8 | cv::Mat IdentityProcessor::operator()(cv::Mat im) { 9 | return im; 10 | } 11 | 12 | namespace { 13 | auto idProcReg = ProcessorRegister("Id"); 14 | } 15 | -------------------------------------------------------------------------------- /Counter/counter.cpp: -------------------------------------------------------------------------------- 1 | #include "counter.hpp" 2 | 3 | pp::Module* pp::CreateModule() { 4 | return new InstanceFactory(); 5 | } 6 | 7 | void CounterInstance::HandleMessage( const pp::Var& var_message ) { 8 | if ( !var_message.is_number() ) 9 | return; //Early exit 10 | auto x = var_message.AsInt(); 11 | count += x; 12 | const pp::Var reply( count ); 13 | PostMessage( reply ); 14 | } 15 | -------------------------------------------------------------------------------- /ImageProc/processor.hpp: -------------------------------------------------------------------------------- 1 | #ifndef PROCESSOR_HPP 2 | #define PROCESSOR_HPP 3 | 4 | #include 5 | #include 6 | 7 | class Processor { 8 | public: 9 | virtual cv::Mat operator()(cv::Mat)=0; 10 | virtual ~Processor() {} 11 | virtual void init( cv::Mat ) {}; 12 | virtual void init( const char* ) {}; 13 | virtual std::string getParameters() { return ""; }; 14 | }; 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /ImageProc/image_proc.hpp: -------------------------------------------------------------------------------- 1 | #ifndef IMAGE_PROC_HPP 2 | #define IMAGE_PROC_HPP 3 | 4 | #include 5 | 6 | class ImageProc { 7 | public: 8 | explicit ImageProc() { 9 | }; 10 | virtual ~ImageProc() {}; 11 | cv::Mat process( std::function const& f, cv::Mat im ) { 12 | return f(im); 13 | }; 14 | cv::Mat process(cv::Mat im) { 15 | auto f = [](cv::Mat x){ return x; }; 16 | return process(f,im); 17 | } 18 | }; 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /Counter/counter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef COUNTER_HPP 2 | #define COUNTER_HPP 3 | 4 | #include "instance_factory.hpp" 5 | 6 | // The CounterInstance that stores count of values passed from webpage 7 | class CounterInstance : public pp::Instance { 8 | public: 9 | explicit CounterInstance( PP_Instance instance ) 10 | : pp::Instance(instance), count(0) {}; 11 | virtual ~CounterInstance( ){}; 12 | virtual void HandleMessage( const pp::Var& ); 13 | private: 14 | void inc(int x=0); 15 | int count; 16 | }; 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /MonteCarlo/test_mc.cpp: -------------------------------------------------------------------------------- 1 | #include "monte_carlo.hpp" 2 | #include 3 | 4 | int main(int argc, char* argv[]) 5 | { 6 | MonteCarlo mc; 7 | 8 | // Function to estimate 9 | auto f = [](double x, double y){ return x*x + y*y < 1 ? 1 : 0; }; 10 | 11 | len_t nPts = 10; 12 | for (int i=0; i<6; ++i ) { 13 | auto res = mc.sim( f, nPts ); 14 | std::cout << nPts << ": Pi = " 15 | << 4.0*res.Mean << " +/- " 16 | << 4.0*res.StDev/sqrt(nPts) << std::endl; 17 | nPts *= 10; 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /Counter/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | NaCl Counter 5 | 6 | 7 | 8 |

Counter using NaCl

9 | 10 |
11 | 12 | 14 |
15 | 16 |

Status NO-STATUS

17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /ImageProc/processor_invert.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | 3 | class InvertProcessor : public Processor { 4 | public: 5 | cv::Mat operator()(cv::Mat); 6 | }; 7 | 8 | cv::Mat InvertProcessor::operator()(cv::Mat im) { 9 | cv::Mat dest; 10 | // Subtract the image from a constant 255 4-channel array 11 | cv::subtract( cv::Scalar(255, 255, 255, 255), im, dest ); 12 | // Set the alpha channel back to fully opaque 13 | cv::add( cv::Scalar(0,0,0,255), dest, im ); 14 | 15 | return im; 16 | } 17 | 18 | namespace { 19 | auto invertProcReg = ProcessorRegister("Invert"); 20 | } 21 | -------------------------------------------------------------------------------- /ImageProc/processor_facedetect.hpp: -------------------------------------------------------------------------------- 1 | #ifndef PROCESSOR_FACEDETECT_HPP 2 | #define PROCESSOR_FACEDETECT_HPP 3 | #include "face_detector.hpp" 4 | 5 | class FaceDetectorProcessor : public FaceDetector { 6 | public: 7 | cv::Mat operator()(cv::Mat); 8 | FaceDetectorProcessor(); 9 | virtual ~FaceDetectorProcessor(){}; 10 | // Helper method to detect faces 11 | virtual void detectFaces(const cv::Mat, std::vector&); 12 | private: 13 | cv::CascadeClassifier face_cascade; 14 | bool xmlLoaded; 15 | static void createOutput(cv::Mat&, cv::Mat&); 16 | static std::string getClassifier(); 17 | }; 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /Counter/instance_factory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef INSTANCE_FACTORY_HPP 2 | #define INSTANCE_FACTORY_HPP 3 | 4 | #include "ppapi/cpp/instance.h" 5 | #include "ppapi/cpp/module.h" 6 | #include "ppapi/cpp/var.h" 7 | 8 | // Factory method called by the browser when first loaded 9 | namespace pp { 10 | Module* CreateModule(); 11 | }; 12 | 13 | // Module used to create instance of NaCl module on webpage 14 | template 15 | class InstanceFactory : public pp::Module { 16 | public: 17 | InstanceFactory( ){}; 18 | virtual ~InstanceFactory(){}; 19 | virtual pp::Instance* CreateInstance( PP_Instance instance ) { 20 | return new T(instance); 21 | }; 22 | }; 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /ImageProc/instance_factory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef INSTANCE_FACTORY_HPP 2 | #define INSTANCE_FACTORY_HPP 3 | 4 | #include "ppapi/cpp/instance.h" 5 | #include "ppapi/cpp/module.h" 6 | #include "ppapi/cpp/var.h" 7 | 8 | // Factory method called by the browser when first loaded 9 | namespace pp { 10 | Module* CreateModule(); 11 | }; 12 | 13 | // Module used to create instance of NaCl module on webpage 14 | template 15 | class InstanceFactory : public pp::Module { 16 | public: 17 | InstanceFactory( ){}; 18 | virtual ~InstanceFactory(){}; 19 | virtual pp::Instance* CreateInstance( PP_Instance instance ) { 20 | return new T(instance); 21 | }; 22 | }; 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /MonteCarlo/instance_factory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef INSTANCE_FACTORY_HPP 2 | #define INSTANCE_FACTORY_HPP 3 | 4 | #include "ppapi/cpp/instance.h" 5 | #include "ppapi/cpp/module.h" 6 | #include "ppapi/cpp/var.h" 7 | 8 | // Factory method called by the browser when first loaded 9 | namespace pp { 10 | Module* CreateModule(); 11 | }; 12 | 13 | // Module used to create instance of NaCl module on webpage 14 | template 15 | class InstanceFactory : public pp::Module { 16 | public: 17 | InstanceFactory( ){}; 18 | virtual ~InstanceFactory(){}; 19 | virtual pp::Instance* CreateInstance( PP_Instance instance ) { 20 | return new T(instance); 21 | }; 22 | }; 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /ImageProc/processor_diff.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | #include 3 | 4 | class DiffProcessor : public Processor { 5 | public: 6 | cv::Mat operator()(cv::Mat); 7 | private: 8 | cv::Mat prevFrame; 9 | }; 10 | 11 | cv::Mat DiffProcessor::operator()(cv::Mat im) { 12 | if ( prevFrame.empty() ) { 13 | prevFrame = im.clone(); 14 | } else { 15 | cv::Mat dest; 16 | cv::absdiff( im, prevFrame, dest); 17 | prevFrame = im.clone(); // NB: need to clone image not just copy ref 18 | // Set alpha channel 19 | cv::add( cv::Scalar(0,0,0,255), dest, im ); 20 | } 21 | return im; 22 | } 23 | 24 | namespace { 25 | auto diffProcReg = ProcessorRegister("Diff"); 26 | } 27 | 28 | -------------------------------------------------------------------------------- /ImageProc/test_processor.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | #include 3 | #include 4 | 5 | int main(int argc, char* argv[]) 6 | { 7 | cv::Mat input = cv::Mat( 2, 2, CV_8UC4, cv::Scalar(128,192,216,255)); 8 | std::cout << "Input = " << std::endl << input << std::endl << std::endl; 9 | 10 | auto processorName = "Invert"; 11 | if (argc > 1) { 12 | processorName = argv[1]; 13 | } 14 | auto processorFactory = SingletonFactory()>>::getInstance(); 15 | auto processor = processorFactory.getObject( processorName )(); 16 | auto output = (*processor)( input ); 17 | 18 | std::cout << "Output = " << std::endl << output << std::endl << std::endl; 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | NaCl 2 | ==== 3 | 4 | A collection of Google Native Client examples designed primarily to help me learn the platform. 5 | Development history so far: 6 | 7 | - Counter - simple example to get the build chain working. 8 | - Monte Carlo - a more complicated example to use user input and background threads. 9 | - ImageProc - use OpenCV naclport for image processing in the browser. 10 | - Simple - found out there are some example files in the distribution 11 | that simplify things. This is why it can be a good idea to read the doc 12 | occasionally. 13 | 14 | Setup 15 | ----- 16 | Please see setup.txt for steps needed to install NaCl SDK and naclports on Ubuntu 14.04. 17 | This works on Amazon AWS t2.micro instance so should be easy to get up and running. 18 | -------------------------------------------------------------------------------- /ImageProc/processor_redchannel.cpp: -------------------------------------------------------------------------------- 1 | #include "singleton_factory.hpp" 2 | #include 3 | 4 | class SingleChannelProcessor : public Processor { 5 | public: 6 | cv::Mat operator()(cv::Mat); 7 | }; 8 | 9 | cv::Mat SingleChannelProcessor::operator()(cv::Mat im) { 10 | cv::Mat dest; 11 | // Split the matrix into its channels 12 | std::vector rgba; 13 | cv::split(im, rgba); 14 | // Blank matrix for Green and Blue channels 15 | cv::Mat blank = cv::Mat( im.size(), CV_8UC1, cv::Scalar(0)); 16 | std::vector rgba_out; 17 | rgba_out.push_back( rgba[0] ); 18 | rgba_out.push_back( rgba[0] ); 19 | rgba_out.push_back( rgba[0] ); 20 | rgba_out.push_back( rgba[3] ); 21 | 22 | cv::merge( rgba_out, dest); 23 | return dest; 24 | } 25 | 26 | namespace { 27 | auto scProcReg = ProcessorRegister("Red"); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /Counter/counterView.js: -------------------------------------------------------------------------------- 1 | // Global handle to module 2 | CounterModule = null; 3 | 4 | // Global status message 5 | statusText = 'NO-STATUS'; 6 | 7 | function pageDidLoad() { 8 | var listener = document.getElementById("listener"); 9 | listener.addEventListener('load', moduleDidLoad, true ); 10 | listener.addEventListener('message', handleMessage, true ); 11 | if ( CounterModule == null ) { 12 | updateStatus( 'LOADING...' ); 13 | } else { 14 | updateStatus(); 15 | } 16 | } 17 | 18 | function moduleDidLoad() { 19 | CounterModule = document.getElementById( 'counter' ); 20 | updateStatus( 'OK' ); 21 | var inc = document.getElementById( 'inc' ); 22 | inc.onclick = function() { CounterModule.postMessage(1); }; 23 | inc.disabled = false; 24 | } 25 | 26 | function handleMessage(message_event) { 27 | updateStatus(message_event.data); 28 | } 29 | 30 | function updateStatus( optMessage ) { 31 | if (optMessage) 32 | statusText = optMessage; 33 | var statusField = document.getElementById('statusField'); 34 | if (statusField) { 35 | statusField.innerHTML = statusText; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /ImageProc/test/simpledom.cpp: -------------------------------------------------------------------------------- 1 | // rapidjson/example/simpledom/simpledom.cpp` 2 | #define CATCH_CONFIG_MAIN 3 | #include "catch/catch.hpp" 4 | #include "rapidjson/document.h" 5 | #include "rapidjson/writer.h" 6 | #include "rapidjson/stringbuffer.h" 7 | #include 8 | 9 | using namespace rapidjson; 10 | 11 | TEST_CASE("JSON Parsed", "[rapidjson]"){ 12 | // 1. Parse a JSON string into DOM. 13 | const char* json = "{\"project\":\"rapidjson\",\"stars\":10}"; 14 | Document d; 15 | d.Parse(json); 16 | 17 | // 2. Modify it by DOM. 18 | Value& s = d["stars"]; 19 | s.SetInt(s.GetInt() + 1); 20 | REQUIRE(s.GetInt() == 11); 21 | 22 | // 3. Stringify the DOM 23 | StringBuffer buffer; 24 | Writer writer(buffer); 25 | d.Accept(writer); 26 | 27 | // Output {"project":"rapidjson","stars":11} 28 | const std::string expectedString = "{\"project\":\"rapidjson\",\"stars\":11}"; 29 | const std::string testString = buffer.GetString(); 30 | REQUIRE( testString == expectedString ); 31 | // std::cout << buffer.GetString() << std::endl; 32 | // return 0; 33 | } 34 | -------------------------------------------------------------------------------- /Simple/Makefile: -------------------------------------------------------------------------------- 1 | # Project Build flags 2 | WARNINGS := -Wno-long-long -Wall -Wswitch-enum -pedantic -Werror 3 | CXXFLAGS := -pthread -std=gnu++11 $(WARNINGS) 4 | 5 | # 6 | # Compute tool paths 7 | # 8 | GETOS := python $(NACL_SDK_ROOT)/tools/getos.py 9 | OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py 10 | OSNAME := $(shell $(GETOS)) 11 | RM := $(OSHELPERS) rm 12 | 13 | PNACL_TC_PATH := $(abspath $(NACL_SDK_ROOT)/toolchain/$(OSNAME)_pnacl) 14 | PNACL_CXX := $(PNACL_TC_PATH)/bin/pnacl-clang++ 15 | PNACL_FINALIZE := $(PNACL_TC_PATH)/bin/pnacl-finalize 16 | PNACL_CXXFLAGS := -I$(NACL_SDK_ROOT)/include $(CXXFLAGS) 17 | PNACL_LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_simple -lnacl_io -lppapi_cpp -lppapi -lpthread 18 | 19 | IMPROC_HEADERS := simple_template.cpp 20 | 21 | # Declare the ALL target first, to make the 'all' target the default build 22 | all: simple_template.pexe 23 | 24 | 25 | clean: 26 | $(RM) simple_template.pexe simple_template.bc 27 | 28 | #$(PROC_OBJECTS): $(PROCESSORS) singleton_factory.hpp 29 | # $(PNACL_CXX) -o $@ $< -O2 $(CXXFLAGS) $(LDFLAGS) 30 | 31 | simple_template.bc: $(IMPROC_HEADERS) $(PROCESSORS) 32 | $(PNACL_CXX) -o $@ $< -O2 $(PNACL_CXXFLAGS) $(PNACL_LDFLAGS) 33 | 34 | simple_template.pexe: simple_template.bc 35 | $(PNACL_FINALIZE) -o $@ $< 36 | 37 | serve: 38 | python -m SimpleHTTPServer 8000 39 | -------------------------------------------------------------------------------- /Simple/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 8 | 9 | 10 | 11 | PPAPI Simple Template 12 | 13 | 14 | 15 | 16 |

PPAPI Simple Template

17 |

Simple template for communication between front end and NaCl backend 18 | using PPAPI Simple library. This example is a cut down combination of 19 | demos/voronoi and tutorials/using_simple_ppapi in the NaCl SDK examples. 20 |

Status: NO-STATUS

21 | 22 | 23 | 24 | 26 |

Output:

27 | 

28 |   

29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/Simple/example.js:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style license that can be
 3 | // found in the LICENSE file.
 4 | 
 5 | // Once we load, hide the plugin
 6 | function moduleDidLoad() {
 7 |   common.hideModule();
 8 | }
 9 | 
10 | // Add event listeners 
11 | function attachListeners() {
12 |   document.getElementById('go').addEventListener( 'click', 
13 |     function() {
14 |       common.naclModule.postMessage({'message':'hello'});
15 |     });
16 |   document.getElementById('quit').addEventListener( 'click', 
17 |     function() {
18 |       common.naclModule.postMessage({'message':'quit'});
19 |     });
20 | }
21 | 
22 | // Called by the common.js module.
23 | // nacl_io/ppapi_simple generates two different types of messages:
24 | // - messages from /dev/tty (prefixed with PS_TTY_PREFIX)
25 | // - exit message (prefixed with PS_EXIT_MESSAGE)
26 | function handleMessage(message) {
27 |   if (message.data.indexOf("exit:") == 0) {
28 |     // When we receive the exit message we post an empty reply back to
29 |     // confirm, at which point the module will exit.
30 |     message.srcElement.postMessage({"exit" : ""});
31 |   } else if (message.data.indexOf("tty:") == 0) {
32 |     common.logMessage(message.data.slice("tty:".length));
33 |   } else {
34 |     console.log("Unhandled message: " + message.data);
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/Counter/Makefile:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2013 The Native Client Authors. All rights reserved.
 2 | # Use of this source code is governed by a BSD-style license that can be
 3 | # found in the LICENSE file.
 4 | 
 5 | #
 6 | # GNU Make based build file.  For details on GNU Make see:
 7 | # http://www.gnu.org/software/make/manual/make.html
 8 | #
 9 | 
10 | # Project Build flags
11 | WARNINGS := -Wno-long-long -Wall -Wswitch-enum -pedantic -Werror
12 | CXXFLAGS := -pthread -std=c++11 $(WARNINGS)
13 | 
14 | #
15 | # Compute tool paths
16 | #
17 | GETOS := python $(NACL_SDK_ROOT)/tools/getos.py
18 | OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py
19 | OSNAME := $(shell $(GETOS))
20 | RM := $(OSHELPERS) rm
21 | 
22 | PNACL_TC_PATH := $(abspath $(NACL_SDK_ROOT)/toolchain/$(OSNAME)_pnacl)
23 | PNACL_CXX := $(PNACL_TC_PATH)/bin/pnacl-clang++
24 | PNACL_FINALIZE := $(PNACL_TC_PATH)/bin/pnacl-finalize
25 | CXXFLAGS := -I$(NACL_SDK_ROOT)/include $(CXXFLAGS) 
26 | LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_cpp -lppapi
27 | 
28 | # Declare the ALL target first, to make the 'all' target the default build
29 | all: counter.pexe
30 | 
31 | clean:
32 | 	$(RM) counter.pexe counter.bc
33 | 
34 | counter.bc: counter.cpp counter.hpp instance_factory.hpp
35 | 	$(PNACL_CXX) -o $@ $< -O2 $(CXXFLAGS) $(LDFLAGS)
36 | 
37 | counter.pexe: counter.bc
38 | 	$(PNACL_FINALIZE) -o $@ $<
39 | 
40 | serve:
41 | 	python -m SimpleHTTPServer 8000
42 | 


--------------------------------------------------------------------------------
/ImageProc/include/catch/LICENSE_1_0.txt:
--------------------------------------------------------------------------------
 1 | Boost Software License - Version 1.0 - August 17th, 2003
 2 | 
 3 | Permission is hereby granted, free of charge, to any person or organization
 4 | obtaining a copy of the software and accompanying documentation covered by
 5 | this license (the "Software") to use, reproduce, display, distribute,
 6 | execute, and transmit the Software, and to prepare derivative works of the
 7 | Software, and to permit third-parties to whom the Software is furnished to
 8 | do so, all subject to the following:
 9 | 
10 | The copyright notices in the Software and this entire statement, including
11 | the above license grant, this restriction and the following disclaimer,
12 | must be included in all copies of the Software, in whole or in part, and
13 | all derivative works of the Software, unless such copies or derivative
14 | works are solely in the form of machine-executable object code generated by
15 | a source language processor.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 | DEALINGS IN THE SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/MonteCarlo/monte_carlo.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef MONTE_CARLO_HPP
 2 | #define MONTE_CARLO_HPP
 3 | 
 4 | #include 
 5 | #include 
 6 | #include 
 7 | 
 8 | typedef long unsigned int len_t;
 9 | 
10 | struct result {
11 |   double Mean;
12 |   double StDev;
13 |   len_t Total; // Total number of points 
14 |   len_t PointCount; // Number that passed
15 | };
16 | 
17 | class MonteCarlo {
18 |   public:
19 |     explicit MonteCarlo() : unifdist(0.0,1.0) {
20 |     };
21 |     virtual ~MonteCarlo() {};
22 |     result sim( std::function const& f, len_t N) {
23 |       // Bind the generator to the first argument of distribution so that
24 |       // we can call with rng() instead of dist(gen).
25 |       // auto rng = std::bind( unifdist, generator );
26 |       
27 |       len_t sum = 0;
28 |       for( len_t i=0; i unifdist;
47 |     
48 | };
49 | 
50 | #endif
51 | 


--------------------------------------------------------------------------------
/MonteCarlo/index.html:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 |   Monte Carlo simulation
 5 |   
 6 |   
 7 | 
 8 | 
 9 |   
Monte Carlo simulation using NaCl

10 | 
11 |   
This page uses 
13 |   Google Native Client to perform a 
15 |   Monte Carlo simulation that estimates the fraction of points in the
16 |   unit square falling below the selected curve by random sampling using the
17 |   selected number of points.  The simulation runs in
18 |   portable native code, taking around 1 second per million points.

19 | 
20 |   
Requires Chrome web browser version 31 or above (not Android app)

21 | 
22 |   

23 |     
24 |     
26 |   

27 | 
28 |    
29 |    
30 |   
31 |   
32 |   
33 |   
Status NO-STATUS

34 | 
35 |   

36 | 
37 |   

38 | 
39 | 
40 | 
41 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/swap.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | //
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_INTERNAL_SWAP_H_
16 | #define RAPIDJSON_INTERNAL_SWAP_H_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | //! Custom swap() to avoid dependency on C++  header
24 | /*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
25 |     \note This has the same semantics as std::swap().
26 | */
27 | template 
28 | inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {
29 |     T tmp = a;
30 |         a = b;
31 |         b = tmp;
32 | }
33 | 
34 | } // namespace internal
35 | RAPIDJSON_NAMESPACE_END
36 | 
37 | #endif // RAPIDJSON_INTERNAL_SWAP_H_
38 | 


--------------------------------------------------------------------------------
/MonteCarlo/d3/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013, Michael Bostock
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | * The name Michael Bostock may not be used to endorse or promote products
15 |   derived from this software without specific prior written permission.
16 | 
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 | DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,
21 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
22 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24 | OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
26 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/strfunc.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
16 | #define RAPIDJSON_INTERNAL_STRFUNC_H_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | //! Custom strlen() which works on different character types.
24 | /*! \tparam Ch Character type (e.g. char, wchar_t, short)
25 |     \param s Null-terminated input string.
26 |     \return Number of characters in the string. 
27 |     \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
28 | */
29 | template 
30 | inline SizeType StrLen(const Ch* s) {
31 |     const Ch* p = s;
32 |     while (*p) ++p;
33 |     return SizeType(p - s);
34 | }
35 | 
36 | } // namespace internal
37 | RAPIDJSON_NAMESPACE_END
38 | 
39 | #endif // RAPIDJSON_INTERNAL_STRFUNC_H_
40 | 


--------------------------------------------------------------------------------
/ImageProc/processor_pulsedetect.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | 
 4 | class PulseDetectionProcessor : public Processor {
 5 |   public:
 6 |     PulseDetectionProcessor() : 
 7 |       level(4), r1(0.4), r2(0.05) // , alpha(50.0), chromAttenuation(1.0) 
 8 |       {};
 9 |     cv::Mat operator()(cv::Mat);
10 |   private:
11 |     int level;
12 |     double r1;
13 |     double r2;
14 |  //   double alpha;
15 |  //   double chromAttenuation;
16 |     cv::Mat prevFrame1;
17 |     cv::Mat prevFrame2;
18 | };
19 | 
20 | cv::Mat PulseDetectionProcessor::operator()(cv::Mat im) {
21 |   cv::Mat dest;
22 |   // Convert to YCrCb color space
23 | //  cv::cvtColor( im, dest, CV_YCrCb2RGB);
24 | 
25 |   // Gaussian blur using image pyramid
26 |   for (auto i=0; i("Pulse Detection (experimental)");
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/MonteCarlo/Makefile:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2013 The Native Client Authors. All rights reserved.
 2 | # Use of this source code is governed by a BSD-style license that can be
 3 | # found in the LICENSE file.
 4 | 
 5 | #
 6 | # GNU Make based build file.  For details on GNU Make see:
 7 | # http://www.gnu.org/software/make/manual/make.html
 8 | #
 9 | 
10 | # Project Build flags
11 | WARNINGS := -Wno-long-long -Wall -Wswitch-enum -pedantic -Werror
12 | CXXFLAGS := -pthread -std=gnu++11 $(WARNINGS)
13 | 
14 | #
15 | # Compute tool paths
16 | #
17 | GETOS := python $(NACL_SDK_ROOT)/tools/getos.py
18 | OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py
19 | OSNAME := $(shell $(GETOS))
20 | RM := $(OSHELPERS) rm
21 | 
22 | PNACL_TC_PATH := $(abspath $(NACL_SDK_ROOT)/toolchain/$(OSNAME)_pnacl)
23 | PNACL_CXX := $(PNACL_TC_PATH)/bin/pnacl-clang++
24 | PNACL_FINALIZE := $(PNACL_TC_PATH)/bin/pnacl-finalize
25 | CXXFLAGS := -I$(NACL_SDK_ROOT)/include $(CXXFLAGS) 
26 | LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_cpp -lppapi
27 | 
28 | # Declare the ALL target first, to make the 'all' target the default build
29 | all: monte_carlo.pexe
30 | 
31 | test_mc: monte_carlo.hpp test_mc.cpp
32 | 	$(CXX) -o test_mc test_mc.cpp -std=c++11
33 | 
34 | clean:
35 | 	$(RM) monte_carlo.pexe monte_carlo.bc
36 | 
37 | monte_carlo.bc: monte_carlo.cpp monte_carlo.hpp instance_factory.hpp mc_instance.hpp singleton_factory.hpp model_circle.cpp model_parabola.cpp
38 | 	$(PNACL_CXX) -o $@ $< model_circle.cpp model_parabola.cpp -O2 $(CXXFLAGS) $(LDFLAGS)
39 | 
40 | monte_carlo.pexe: monte_carlo.bc
41 | 	$(PNACL_FINALIZE) -o $@ $<
42 | 
43 | serve:
44 | 	python -m SimpleHTTPServer 8000
45 | 


--------------------------------------------------------------------------------
/ImageProc/processor_gblur.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include "include/rapidjson/document.h"
 4 | #include 
 5 | 
 6 | class GBlurProcessor : public Processor {
 7 |   public:
 8 |     GBlurProcessor() : level(4) {};
 9 |     GBlurProcessor(int level_) : level(level_) {};
10 |     cv::Mat operator()(cv::Mat);
11 |     void init(const char* json);
12 |     std::string getParameters();
13 |   private:
14 |     int level;
15 | };
16 | 
17 | void GBlurProcessor::init(const char* json) {
18 |   // Read json string to set properties
19 |   using namespace rapidjson;
20 |   Document document;
21 |   document.Parse(json);
22 |   assert(document.IsObject());
23 |   assert(document.HasMember("level"));
24 |   level = document["level"].GetInt();
25 | }
26 | 
27 | std::string GBlurProcessor::getParameters() {
28 |   std::ostringstream os;
29 |   os <<  "{\"level\":" << level << "}";
30 |   return os.str();
31 | }
32 | 
33 | cv::Mat GBlurProcessor::operator()(cv::Mat im) {
34 |   cv::Mat dest;
35 |   const int in_rows = im.rows;
36 |   const int in_cols = im.cols;
37 |   // for (auto i=0; i("Gaussian Blur");
59 | }
60 | 
61 | 


--------------------------------------------------------------------------------
/ImageProc/processor_laplacian.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | // OpenCV Laplacian Derivative example from doc
 6 | // http://docs.opencv.org/doc/tutorials/imgtrans/laplace_operator/laplace_operator.html
 7 | class LaplacianProcessor : public Processor {
 8 |   public:
 9 |     cv::Mat operator()(cv::Mat);
10 |   private:
11 |     static void createOutput(cv::Mat&, cv::Mat&);
12 | };
13 | 
14 | cv::Mat LaplacianProcessor::operator()(cv::Mat im) {
15 |  
16 |   cv::Mat grey;
17 |   // Remove noise by blurring with Gaussian
18 |   cv::GaussianBlur(im, im, cv::Size(3,3), 0,0, cv::BORDER_DEFAULT);
19 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
20 |   
21 |   int kernel_size = 3;
22 |   int scale = 1;
23 |   int delta = 0;
24 |   int ddepth = CV_16S;
25 |   cv::Mat lap;
26 |   cv::Laplacian(grey, lap, ddepth, kernel_size, scale, delta, cv::BORDER_DEFAULT);
27 | 
28 |   // Scaled abs laplacian
29 |   cv::Mat absLap;
30 | 
31 |   cv::convertScaleAbs(lap, absLap);
32 | 
33 |   // Display intermediate images for debugging
34 |   cv::Mat dest;
35 |   createOutput( absLap, dest );
36 |   return dest; 
37 | }
38 | 
39 | void LaplacianProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
40 | {
41 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
42 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
43 |   std::vector rgba_out;
44 |   rgba_out.push_back( src );
45 |   rgba_out.push_back( src );
46 |   rgba_out.push_back( src );
47 |   rgba_out.push_back( fullAlpha );
48 | 
49 |   cv::merge( rgba_out, dest);
50 | }
51 | 
52 | namespace {
53 |   auto scProcReg = ProcessorRegister("Laplacian");
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/ImageProc/index.html:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 |   OpenCV in Chrome using NaCl
 5 |   
 6 |   
 7 | 
 8 | 
 9 |   
OpenCV in Chrome using NaCl

10 | 
11 |   
This page uses 
13 |   Google Native Client to tie in to the C++ OpenCV computer vision library.
15 |   This allows realtime image processing of the webcam feed from within the
16 |   browser.
17 |   
  
18 |   NB: No data is sent back to this website.
19 |   

20 | 
21 |   
Requires Chrome web browser version 44 or above (not Android app)

22 | 
23 |    
24 |    
25 |    
26 |   
27 | 
28 |   

29 |     
30 |     
32 |   

33 | 
34 |   

35 |     
36 |     
37 |     
38 |   

39 | 
40 |   
Status NO-STATUS

41 | 
42 |   GitHub repo
43 | 
44 |   
46 |   
47 |   
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/ImageProc/Makefile:
--------------------------------------------------------------------------------
 1 | # Project Build flags
 2 | WARNINGS := -Wno-long-long -Wall -pedantic -Werror # -Wswitch-enum -pedantic -Werror
 3 | CXXFLAGS := -pthread -std=gnu++11 $(WARNINGS)
 4 | 
 5 | #
 6 | # Compute tool paths
 7 | #
 8 | GETOS := python $(NACL_SDK_ROOT)/tools/getos.py
 9 | OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py
10 | OSNAME := $(shell $(GETOS))
11 | RM := $(OSHELPERS) rm
12 | 
13 | PNACL_TC_PATH := $(abspath $(NACL_SDK_ROOT)/toolchain/$(OSNAME)_pnacl)
14 | PNACL_CXX := $(PNACL_TC_PATH)/bin/pnacl-clang++
15 | PNACL_FINALIZE := $(PNACL_TC_PATH)/bin/pnacl-finalize
16 | PNACL_CXXFLAGS := -I$(NACL_SDK_ROOT)/include $(CXXFLAGS) 
17 | LDFLAGS := -lopencv_objdetect -lopencv_imgproc -lopencv_core -lz 
18 | PNACL_LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_cpp -lppapi -lpthread $(LDFLAGS)
19 | 
20 | PROCESSORS := $(wildcard processor_*.cpp)
21 | PROC_OBJECTS := $(PROCESSORS:.cpp=.bc)
22 | 
23 | IMPROC_HEADERS := image_proc.cpp image_proc.hpp instance_factory.hpp improc_instance.hpp singleton_factory.hpp
24 | 
25 | # Declare the ALL target first, to make the 'all' target the default build
26 | all: image_proc.pexe
27 | 
28 | # Create individual test
29 | .PHONY: test
30 | test:
31 | 	g++ -g -o test_display test_display.cpp $(PROC) -std=c++0x -lopencv_highgui $(LDFLAGS)
32 | 
33 | .PHONY: test_processor
34 | test_processor: test_processor.cpp singleton_factory.hpp $(PROCESSORS)
35 | 	g++ -g -o test_processor test_processor.cpp $(PROCESSORS) -std=c++0x $(LDFLAGS)
36 | 
37 | clean:
38 | 	$(RM) image_proc.pexe image_proc.bc
39 | 
40 | #$(PROC_OBJECTS): $(PROCESSORS) singleton_factory.hpp
41 | #	$(PNACL_CXX) -o $@ $< -O2 $(CXXFLAGS) $(LDFLAGS)
42 | 
43 | image_proc.bc:  $(IMPROC_HEADERS) $(PROCESSORS) url_loader_handler.cpp
44 | 	$(PNACL_CXX) -o $@ $< $(PROCESSORS) url_loader_handler.cpp -O2 $(PNACL_CXXFLAGS) $(PNACL_LDFLAGS)
45 | 
46 | image_proc.pexe: image_proc.bc
47 | 	$(PNACL_FINALIZE) -o $@ $<
48 | 
49 | serve:
50 | 	python -m SimpleHTTPServer 8000
51 | 


--------------------------------------------------------------------------------
/MonteCarlo/mc_instance.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef MC_INSTANCE
 2 | #define MC_INSTANCE
 3 | 
 4 | #include "singleton_factory.hpp"
 5 | #include "instance_factory.hpp"
 6 | #include "monte_carlo.hpp"
 7 | #include "ppapi/cpp/var_dictionary.h"
 8 | #include "ppapi/cpp/var_array.h"
 9 | #include "ppapi/utility/completion_callback_factory.h"
10 | #include "ppapi/utility/threading/simple_thread.h"
11 | 
12 | // The MonteCarloInstance that stores 
13 | class MonteCarloInstance : public pp::Instance {
14 |   public:
15 |     explicit MonteCarloInstance( PP_Instance instance ) 
16 |       : pp::Instance(instance), callback_factory_(this), sim_thread_(this) {};
17 |     virtual ~MonteCarloInstance( ){ sim_thread_.Join(); };
18 |     virtual void HandleMessage( const pp::Var& );
19 |     virtual bool Init(uint32_t /*argc*/,
20 |         const char * /*argn*/ [],
21 |         const char * /*argv*/ []) {
22 |       sim_thread_.Start();
23 |       sim_thread_.message_loop().PostWork( 
24 |         callback_factory_.NewCallback( &MonteCarloInstance::Version ));
25 |       return true;
26 |     }
27 | 
28 |   private:
29 |     bool run_simulation_;
30 |     MonteCarlo mc;
31 |     pp::CompletionCallbackFactory callback_factory_;
32 |     pp::SimpleThread sim_thread_; // Thread for MC simulations
33 |     void Simulate(int32_t, std::function, unsigned int N); 
34 |     pp::VarDictionary PostResponse( len_t runningTotal, len_t i);
35 |     void Version( int32_t ) {
36 |       pp::VarDictionary msg;
37 |       msg.Set( "Type", "version" );
38 |       msg.Set( "Version", "Monte Carlo Version 0.2.1" );
39 |       // Get models
40 |       auto modelFactory = SingletonFactory>::getInstance();
41 |       auto modelList = modelFactory.getNames();
42 |       pp::VarArray msgModelList;
43 |       for ( size_t i=0; i < modelList.size(); i ++ ) {
44 |         msgModelList.Set( i, modelList[i] );
45 |       }
46 |       msg.Set( "Models", msgModelList );
47 |       PostMessage( msg );
48 |     }
49 | };
50 | 
51 | #endif
52 | 


--------------------------------------------------------------------------------
/ImageProc/processor_cartoon.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | class CartoonProcessor : public Processor {
 6 |   public:
 7 |     cv::Mat operator()(cv::Mat);
 8 |   private:
 9 |     static void createOutput(cv::Mat&, cv::Mat&);
10 | };
11 | 
12 | cv::Mat CartoonProcessor::operator()(cv::Mat im) {
13 |   cv::Mat grey;
14 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
15 |   // Get rid of speckle first by median filter
16 |   const int MEDIAN_KERNEL_SIZE = 9;
17 |   cv::medianBlur(grey, grey, MEDIAN_KERNEL_SIZE);
18 |   cv::Mat gradX;
19 |   cv::Scharr(grey, gradX, CV_32F, 1, 0);
20 |   cv::Mat gradY;
21 |   cv::Scharr(grey, gradY, CV_32F, 0, 1);
22 |   cv::Mat gradient;
23 |   cv::subtract( gradX, gradY, gradient);
24 |   cv::convertScaleAbs(gradient, gradient);
25 | 
26 |   cv::Mat blurred;
27 |   cv::blur(gradient, blurred, cv::Size(9,9));
28 | 
29 |   cv::Mat thresh;
30 |   cv::threshold(gradient, thresh, 150, 255, cv::THRESH_BINARY_INV );
31 | 
32 |   // Display intermediate images for debugging
33 |   cv::Mat dest;
34 |   createOutput( thresh, dest );
35 |   return dest; 
36 | 
37 |   /* 
38 |   cv::Mat segmented, gray, edges, edgesBgr;
39 |   cv::pyrMeanShiftFiltering(im, segmented, 15, 40);
40 |   cv::cvtColor(segmented, gray, CV_BGR2GRAY);
41 |   cv::Canny(gray, edges, 150, 150);
42 |   cv::cvtColor(edges, edgesBgr, CV_GRAY2BGR);
43 |   cv::Mat result = segmented - edgesBgr;
44 |   return result;
45 |   */
46 | }
47 | 
48 | void CartoonProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
49 | {
50 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
51 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
52 |   std::vector rgba_out;
53 |   rgba_out.push_back( src );
54 |   rgba_out.push_back( src );
55 |   rgba_out.push_back( src );
56 |   rgba_out.push_back( fullAlpha );
57 | 
58 |   cv::merge( rgba_out, dest);
59 | }
60 | 
61 | namespace {
62 |   auto scProcReg = ProcessorRegister("Cartoon");
63 | }
64 | 
65 | 


--------------------------------------------------------------------------------
/GettingStarted/Makefile:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2013 The Native Client Authors. All rights reserved.
 2 | # Use of this source code is governed by a BSD-style license that can be
 3 | # found in the LICENSE file.
 4 | 
 5 | #
 6 | # GNU Make based build file.  For details on GNU Make see:
 7 | # http://www.gnu.org/software/make/manual/make.html
 8 | #
 9 | 
10 | #
11 | # Get pepper directory for toolchain and includes.
12 | #
13 | # If NACL_SDK_ROOT is not set, then assume it can be found three directories up.
14 | #
15 | THIS_MAKEFILE := $(abspath $(lastword $(MAKEFILE_LIST)))
16 | NACL_SDK_ROOT ?= $(abspath $(dir $(THIS_MAKEFILE))../..)
17 | 
18 | # Project Build flags
19 | WARNINGS := -Wno-long-long -Wall -Wswitch-enum -pedantic -Werror
20 | # CXXFLAGS := -pthread -std=gnu++98 $(WARNINGS)
21 | CXXFLAGS := -pthread -std=c++11 $(WARNINGS)
22 | 
23 | #
24 | # Compute tool paths
25 | #
26 | GETOS := python $(NACL_SDK_ROOT)/tools/getos.py
27 | OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py
28 | OSNAME := $(shell $(GETOS))
29 | RM := $(OSHELPERS) rm
30 | 
31 | PNACL_TC_PATH := $(abspath $(NACL_SDK_ROOT)/toolchain/$(OSNAME)_pnacl)
32 | PNACL_CXX := $(PNACL_TC_PATH)/bin/pnacl-clang++
33 | PNACL_FINALIZE := $(PNACL_TC_PATH)/bin/pnacl-finalize
34 | CXXFLAGS := -I$(NACL_SDK_ROOT)/include -std=c++11
35 | LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_cpp -lppapi
36 | 
37 | #
38 | # Disable DOS PATH warning when using Cygwin based tools Windows
39 | #
40 | CYGWIN ?= nodosfilewarning
41 | export CYGWIN
42 | 
43 | 
44 | # Declare the ALL target first, to make the 'all' target the default build
45 | all: hello_tutorial.pexe
46 | 
47 | clean:
48 | 	$(RM) hello_tutorial.pexe hello_tutorial.bc
49 | 
50 | hello_tutorial.bc: hello_tutorial.cc
51 | 	$(PNACL_CXX) -o $@ $< -O2 $(CXXFLAGS) $(LDFLAGS)
52 | 
53 | hello_tutorial.pexe: hello_tutorial.bc
54 | 	$(PNACL_FINALIZE) -o $@ $<
55 | 
56 | 
57 | #
58 | # Makefile target to run the SDK's simple HTTP server and serve this example.
59 | #
60 | HTTPD_PY := python httpd.py
61 | 
62 | .PHONY: serve
63 | serve: all
64 | 	$(HTTPD_PY) -C $(CURDIR)
65 | 


--------------------------------------------------------------------------------
/MonteCarlo/singleton_factory.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SINGLETON_FACTORY_HPP
 2 | #define SINGLETON_FACTORY_HPP
 3 | 
 4 | #include 
 5 | #include 
 6 | #include 
 7 | #include 
 8 | 
 9 | template 
10 | class SingletonFactory {
11 |   public:
12 |     T getObject( std::string name ) const;
13 |     std::vector getNames() const;
14 |     static SingletonFactory& getInstance();
15 |     void registerObject( std::string name, T fcn) ;
16 |     ~SingletonFactory(){};
17 |   private:
18 |     std::map SingletonCreatorFcns;
19 |     SingletonFactory(){};
20 | };
21 | 
22 | template 
23 | class ObjectRegister {
24 |   // Helper class to allow registration of scenes by construction of global
25 |   // variables in a hidden namespace.  
26 |   // See p164 of Joshi "C++ design patterns for derivatives pricing"
27 |   // Note that the C++11 language features make this pattern a lot simpler.
28 | 
29 |   public:
30 |     ObjectRegister( std::string name, T fcn ) {
31 |       SingletonFactory& theFactory = SingletonFactory::getInstance();
32 |       theFactory.registerObject( name, fcn );
33 |     }
34 | };
35 | 
36 | template 
37 | void SingletonFactory::registerObject( std::string name, T fcn) {
38 |   SingletonCreatorFcns.insert( 
39 |     std::pair(name, fcn));
40 | }
41 | 
42 | template 
43 | T SingletonFactory::getObject( std::string name) const {
44 |   auto it = SingletonCreatorFcns.find(name);
45 |   if ( it == SingletonCreatorFcns.end() ) {
46 |     return NULL;
47 |   }
48 |   return (it->second);
49 | }
50 | 
51 | template 
52 | std::vector SingletonFactory::getNames( ) const {
53 |   std::vector names;
54 |   for (auto entry : SingletonCreatorFcns ) {
55 |     names.push_back( entry.first );
56 |   }
57 |   return names;
58 | }
59 | 
60 | template 
61 | SingletonFactory& SingletonFactory::getInstance(){
62 |   static SingletonFactory theFactory;
63 |   return theFactory;
64 | }
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/ImageProc/processor_skindetect.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | class SkinDetectProcessor : public Processor {
 6 |   public:
 7 |     cv::Mat operator()(cv::Mat);
 8 |   private:
 9 |     static void createOutput(cv::Mat&, cv::Mat&);
10 | };
11 | 
12 | cv::Mat SkinDetectProcessor::operator()(cv::Mat im) {
13 |   // SkinDetect segmentation demo from the OpenCV documentation
14 |   cv::Mat converted;
15 |   cv::cvtColor( im, im, CV_RGBA2BGR );
16 |   cv::cvtColor( im, converted, CV_BGR2HSV );
17 | 
18 |   cv::Mat thresh;
19 |   // Skin Cluster in YCbCr space from 'Explicit Image Detection using 
20 |   // YCbCr Space Color Model as Skin Detection' by Basilo, et al.
21 |   // cv::Scalar colorLow {80, 135, 85};
22 |   // cv::Scalar colorHigh {255, 180, 135};
23 | 
24 |   // HSV skin range from PyImageSearch 2014-08-18 blog post 
25 |   cv::Scalar colorLow {0, 48, 80};
26 |   cv::Scalar colorHigh {20, 255, 255};
27 | 
28 |   cv::inRange(converted, colorLow, colorHigh, thresh);
29 |   
30 |   // Open image to remove noise
31 |   cv::Mat kernel = cv::getStructuringElement( 
32 |     cv::MORPH_ELLIPSE, cv::Size(3,3));
33 |   cv::Mat skinMask;
34 |   cv::morphologyEx( thresh, skinMask, cv::MORPH_OPEN, 
35 |     kernel, cv::Point(-1,1), 2);
36 |   cv::GaussianBlur(skinMask, skinMask, cv::Size(3,3), 0, 0);
37 | 
38 | 
39 |   cv::Mat out;
40 |   cv::bitwise_and(im, im, out, skinMask);
41 | 
42 |   // Display intermediate images for debugging
43 |   // cv::Mat dest;
44 |   // createOutput( markers, dest );
45 |   cv::cvtColor( out, out, CV_BGR2RGBA );
46 |   return out; 
47 | }
48 | 
49 | void SkinDetectProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
50 | {
51 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
52 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
53 |   std::vector rgba_out;
54 |   rgba_out.push_back( src );
55 |   rgba_out.push_back( src );
56 |   rgba_out.push_back( src );
57 |   rgba_out.push_back( fullAlpha );
58 | 
59 |   cv::merge( rgba_out, dest);
60 | }
61 | 
62 | namespace {
63 |   auto scProcReg = ProcessorRegister("Skin Detector");
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/ImageProc/improc_instance.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef IMPROC_INSTANCE
 2 | #define IMPROC_INSTANCE
 3 | 
 4 | #include "singleton_factory.hpp"
 5 | #include "instance_factory.hpp"
 6 | #include "image_proc.hpp"
 7 | #include "ppapi/cpp/var_dictionary.h"
 8 | #include "ppapi/cpp/var_array.h"
 9 | #include "ppapi/cpp/var_array_buffer.h"
10 | #include "ppapi/utility/completion_callback_factory.h"
11 | #include "ppapi/utility/threading/simple_thread.h"
12 | 
13 | // The ImageProcInstance that stores 
14 | class ImageProcInstance : public pp::Instance {
15 |   public:
16 |     explicit ImageProcInstance( PP_Instance instance ) 
17 |       : pp::Instance(instance), callback_factory_(this), proc_thread_(this) {};
18 |     virtual ~ImageProcInstance( ){ proc_thread_.Join(); };
19 |     virtual void HandleMessage( const pp::Var& );
20 |     virtual bool Init(uint32_t /*argc*/,
21 |         const char * /*argn*/ [],
22 |         const char * /*argv*/ []) {
23 |       proc_thread_.Start();
24 |       proc_thread_.message_loop().PostWork( 
25 |         callback_factory_.NewCallback( &ImageProcInstance::Version ));
26 |       return true;
27 |     }
28 | 
29 |   private:
30 |     bool run_simulation_;
31 |     std::string processorName; // Name of currently selected processor
32 |     std::unique_ptr processor;
33 |     pp::CompletionCallbackFactory callback_factory_;
34 |     pp::SimpleThread proc_thread_; // Thread for image processor 
35 |     void Process(cv::Mat); 
36 |     void PostTest(); 
37 |     void SendStatus(const std::string& status); 
38 |     pp::VarDictionary PostResponse( cv::Mat );
39 |     void Version( int32_t ) {
40 |       pp::VarDictionary msg;
41 |       msg.Set( "Type", "version" );
42 |       msg.Set( "Version", "Image Processor 0.4.1" );
43 |       // Get processor
44 |       auto processorFactory = SingletonFactory()>>::getInstance();
45 |       auto processorList = processorFactory.getNames();
46 |       pp::VarArray msgProcessorList;
47 |       for ( size_t i=0; i < processorList.size(); i ++ ) {
48 |         msgProcessorList.Set( i, processorList[i] );
49 |       }
50 |       msg.Set( "Processors", msgProcessorList );
51 |       PostMessage( msg );
52 |     }
53 | };
54 | 
55 | #endif
56 | 


--------------------------------------------------------------------------------
/ImageProc/processor_probabilistichoughline.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | // OpenCV ProbabilisticHoughLine Derivative example from doc
 6 | // http://docs.opencv.org/doc/tutorials/imgtrans/sobel_derivatives/sobel_derivaties.html
 7 | class ProbabilisticHoughLineProcessor : public Processor {
 8 |   public:
 9 |     cv::Mat operator()(cv::Mat);
10 |   private:
11 |     static void createOutput(cv::Mat&, cv::Mat&);
12 | };
13 | 
14 | cv::Mat ProbabilisticHoughLineProcessor::operator()(cv::Mat im) {
15 |  
16 |   cv::Mat grey;
17 |   // Remove noise by blurring with Gaussian
18 |   cv::GaussianBlur(im, im, cv::Size(3,3), 0,0, cv::BORDER_DEFAULT);
19 | 
20 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
21 |   
22 |   // Canny edge detector
23 |   int lowThreshold = 50;
24 |   int ratio = 4;
25 |   int kernel_size = 3;
26 |   cv::Mat detected_edges;
27 |   cv::Canny( grey, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size);
28 | 
29 |   // Hough line transform
30 |   std::vector lines;
31 |   int houghRho = 1; // pixel
32 |   double houghTheta = CV_PI/180; //radians
33 |   int houghThreshold = 50;
34 |   int minLineLength = 50;
35 |   int maxLineGap = 10;
36 |   cv::HoughLinesP( detected_edges, lines, houghRho, houghTheta, 
37 |     houghThreshold, minLineLength, maxLineGap);
38 | 
39 |   cv::Mat dest;
40 |   cv::cvtColor( detected_edges, dest, CV_GRAY2BGR);
41 | 
42 |   // Draw detected lines
43 |   for( auto line : lines ) {
44 |     cv::line(dest, cv::Point(line[0],line[1]), 
45 |       cv::Point(line[2], line[3]), cv::Scalar(0,255,0), 2, CV_AA);
46 |   }
47 | 
48 |   cv::cvtColor( dest, dest, CV_BGR2RGBA );
49 |   return dest; 
50 | }
51 | 
52 | void ProbabilisticHoughLineProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
53 | {
54 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
55 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
56 |   std::vector rgba_out;
57 |   rgba_out.push_back( src );
58 |   rgba_out.push_back( src );
59 |   rgba_out.push_back( src );
60 |   rgba_out.push_back( fullAlpha );
61 | 
62 |   cv::merge( rgba_out, dest);
63 | }
64 | 
65 | namespace {
66 |   auto scProcReg = ProcessorRegister(
67 |     "Probabilistic Hough Line Transform");
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/ImageProc/processor_smiley.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/objdetect/objdetect.hpp"
 3 | #include "opencv2/imgproc/imgproc.hpp"
 4 | #include "processor_facedetect.hpp"
 5 | #include 
 6 | #include 
 7 | 
 8 | class SmileyProcessor : public Processor {
 9 |   public:
10 |     cv::Mat operator()(cv::Mat);
11 |     SmileyProcessor();
12 |     virtual ~SmileyProcessor(){};
13 |     void init(cv::Mat); // Add image to paste
14 |   private:
15 |     cv::Mat smiley;
16 |     static void createOutput(cv::Mat&, cv::Mat&);
17 |     std::unique_ptr innerFaceDetector;
18 | };
19 | 
20 | SmileyProcessor::SmileyProcessor() {
21 |   // Use inner FaceDetector processor for finding faces in image
22 |   innerFaceDetector = std::unique_ptr{new FaceDetectorProcessor()};
23 | }
24 | 
25 | void SmileyProcessor::init( cv::Mat im ) {
26 |   cv::cvtColor( im, im, CV_RGBA2BGR );
27 |   smiley = im;
28 | }
29 | 
30 | cv::Mat SmileyProcessor::operator()(cv::Mat im) {
31 |   // Smiley segmentation demo from the OpenCV documentation
32 |   cv::cvtColor( im, im, CV_RGBA2BGR );
33 | 
34 |   std::vector faces;
35 |   innerFaceDetector->detectFaces(im, faces);
36 |   
37 |   for ( size_t i=0; i < faces.size(); i++ ) {
38 |     cv::Mat tmp( faces[i].size(), CV_8UC4 );
39 |     cv::resize( smiley, tmp, faces[i].size());
40 |     cv::Mat roi = im( faces[i] );    
41 |     cv::Mat mask( tmp.size(), CV_8UC1 );
42 |     cv::compare( tmp, cv::Scalar(100,100,100), mask, cv::CMP_NE);
43 |     tmp.copyTo( roi, mask );
44 |     // cv::rectangle( im, faces[i], cv::Scalar(0,255,0), 2);
45 |   }
46 | 
47 |   // Display intermediate images for debugging
48 |   // cv::Mat dest;
49 |   // createOutput( markers, dest );
50 |   cv::cvtColor( im, im, CV_BGR2RGBA );
51 |   return im; 
52 | }
53 | 
54 | void SmileyProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
55 | {
56 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
57 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
58 |   std::vector rgba_out;
59 |   rgba_out.push_back( src );
60 |   rgba_out.push_back( src );
61 |   rgba_out.push_back( src );
62 |   rgba_out.push_back( fullAlpha );
63 | 
64 |   cv::merge( rgba_out, dest);
65 | }
66 | 
67 | namespace {
68 |   auto scProcReg = ProcessorRegister("Smiley!");
69 | }
70 | 


--------------------------------------------------------------------------------
/ImageProc/test_display.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include 
 3 | #include 
 4 | #include 
 5 | #include 
 6 | #include 
 7 | 
 8 | int main(int argc, char* argv[])
 9 | {
10 | 
11 |   const char* fname = "mmcdonne.jpg";
12 |   const char* json = "";
13 |   if (argc > 1) {
14 |     fname = argv[1];
15 |   }
16 |   if (argc > 2) {
17 |     json = argv[2];
18 |   }
19 |   cv::Mat input;
20 |   input = cv::imread( fname, CV_LOAD_IMAGE_COLOR );
21 |   if (!input.data) {
22 |     std::cout << "Could not read image " << fname << std::endl;
23 |     return -1;
24 |   }
25 |   // Processors expect 8UC4
26 |   cv::Mat im;
27 |   cv::cvtColor( input, im, CV_BGR2RGBA );
28 |   
29 |   // Use first processor
30 |   auto processorFactory = SingletonFactory()>>::getInstance();
31 |   auto names = processorFactory.getNames();
32 |   auto processor = processorFactory.getObject( names[0] )();
33 |   if ( names[0] == "Smiley!" ) {
34 |     cv::Mat smiley;
35 |     smiley = cv::imread( "smiley_200x200.png", CV_LOAD_IMAGE_UNCHANGED );
36 |     processor->init( smiley );
37 |   }
38 |   if ( json != "" ) {
39 |     std::cout << json << std::endl;
40 |     processor->init(json);
41 |   }
42 |   std::cout << "Paramters:" << processor->getParameters() << std::endl;
43 |   auto output = (*processor)( im );
44 |   std::cout << "In: " << input.cols<< "x" << input.rows << " "
45 |             << "Out: " << output.cols << "x" << output.rows << std::endl;
46 |   cv::cvtColor( output, output, CV_RGBA2BGR );
47 |   
48 |   cv::namedWindow( "Input and Processed", CV_WINDOW_AUTOSIZE );
49 |   // Create large image showing original and processed side by side
50 |   cv::Mat combined(std::max(input.rows,output.rows), 
51 |     input.cols + output.cols + input.cols, input.type());
52 |   cv::Mat roiLeft = combined(cv::Rect(0,0,input.cols,input.rows));
53 |   cv::Mat roiCentre = combined(cv::Rect(input.cols,0,output.cols,output.rows));
54 |   cv::Mat roiRight = combined(cv::Rect(2*input.cols,0,output.cols,output.rows));
55 |   input.copyTo( roiLeft );
56 |   output.copyTo( roiRight );
57 |   // Create abs diff image
58 |   cv::Mat diff;
59 |   cv::absdiff(input, output, diff);
60 |   cv::convertScaleAbs(diff, diff);
61 |   diff.copyTo( roiCentre );
62 | 
63 |   cv::imshow( "Input and Processed", combined);
64 |   cv::moveWindow( "Input and Processed", 100, 100 );
65 |   cv::waitKey();
66 | 
67 |   return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/ImageProc/processor_houghline.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | // OpenCV HoughLine Derivative example from doc
 6 | // http://docs.opencv.org/doc/tutorials/imgtrans/sobel_derivatives/sobel_derivaties.html
 7 | class HoughLineProcessor : public Processor {
 8 |   public:
 9 |     cv::Mat operator()(cv::Mat);
10 |   private:
11 |     static void createOutput(cv::Mat&, cv::Mat&);
12 | };
13 | 
14 | cv::Mat HoughLineProcessor::operator()(cv::Mat im) {
15 |  
16 |   cv::Mat grey;
17 |   // Remove noise by blurring with Gaussian
18 |   cv::GaussianBlur(im, im, cv::Size(3,3), 0,0, cv::BORDER_DEFAULT);
19 | 
20 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
21 |   
22 |   // Canny edge detector
23 |   int lowThreshold = 50;
24 |   int ratio = 4;
25 |   int kernel_size = 3;
26 |   cv::Mat detected_edges;
27 |   cv::Canny( grey, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size);
28 | 
29 |   // Hough line transform
30 |   std::vector lines;
31 |   int houghRho = 1; // pixel
32 |   double houghTheta = CV_PI/180; //radians
33 |   int houghThreshold = 100;
34 |   int srn = 0;
35 |   int stn = 0;
36 |   cv::HoughLines( detected_edges, lines, houghRho, houghTheta, houghThreshold, srn, stn);
37 | 
38 |   // Display intermediate images for debugging
39 |   cv::Mat dest;
40 |   cv::cvtColor( detected_edges, dest, CV_GRAY2BGR);
41 | 
42 |   // Draw detected lines
43 |   for( auto line : lines ) {
44 |     float rho = line[0], theta = line[1];
45 |     cv::Point pt1, pt2;
46 |     double a = cos(theta), b = sin(theta);
47 |     double x0 = a*rho, y0 = b*rho;
48 |     pt1.x = cvRound(x0 + 1000*(-b));
49 |     pt1.y = cvRound(y0 + 1000*(a));
50 |     pt2.x = cvRound(x0 - 1000*(-b));
51 |     pt2.y = cvRound(y0 - 1000*(a));
52 |     cv::line(dest, pt1, pt2, cv::Scalar(0,255,0), 2, CV_AA);
53 |   }
54 | 
55 |   cv::cvtColor( dest, dest, CV_BGR2RGBA );
56 |   return dest; 
57 | 
58 | }
59 | 
60 | void HoughLineProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
61 | {
62 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
63 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
64 |   std::vector rgba_out;
65 |   rgba_out.push_back( src );
66 |   rgba_out.push_back( src );
67 |   rgba_out.push_back( src );
68 |   rgba_out.push_back( fullAlpha );
69 | 
70 |   cv::merge( rgba_out, dest);
71 | }
72 | 
73 | namespace {
74 |   auto scProcReg = ProcessorRegister("Hough Line Transform");
75 | }
76 | 
77 | 


--------------------------------------------------------------------------------
/ImageProc/singleton_factory.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SINGLETON_FACTORY_HPP
 2 | #define SINGLETON_FACTORY_HPP
 3 | 
 4 | #include 
 5 | #include 
 6 | #include 
 7 | #include 
 8 | #include 
 9 | #include "processor.hpp"
10 | 
11 | template 
12 | class SingletonFactory {
13 |   public:
14 |     T getObject( std::string name ) const;
15 |     std::vector getNames() const;
16 |     static SingletonFactory& getInstance();
17 |     void registerObject( std::string name, T fcn) ;
18 |     ~SingletonFactory(){};
19 |   private:
20 |     std::map SingletonCreatorFcns;
21 |     SingletonFactory(){};
22 | };
23 | 
24 | template 
25 | class ObjectRegister {
26 |   // Helper class to allow registration of scenes by construction of global
27 |   // variables in a hidden namespace.  
28 |   // See p164 of Joshi "C++ design patterns for derivatives pricing"
29 |   // Note that the C++11 language features make this pattern a lot simpler.
30 | 
31 |   public:
32 |     ObjectRegister( std::string name, T fcn ) {
33 |       auto& theFactory = SingletonFactory::getInstance();
34 |       theFactory.registerObject( name, fcn );
35 |     }
36 | };
37 | 
38 | // Singleton factory for registering derived Processor classes 
39 | template 
40 | class ProcessorRegister {
41 |   public:
42 |     ProcessorRegister( std::string name ) {
43 |       auto& theFactory = 
44 |         SingletonFactory()>>::getInstance();
45 |       theFactory.registerObject( name, []() { return
46 |         std::unique_ptr(new T());} );
47 |     }
48 | };
49 | 
50 | 
51 | template 
52 | void SingletonFactory::registerObject( std::string name, T fcn) {
53 |   SingletonCreatorFcns.insert( 
54 |     std::pair(name, fcn));
55 | }
56 | 
57 | template 
58 | T SingletonFactory::getObject( std::string name) const {
59 |   auto it = SingletonCreatorFcns.find(name);
60 |   if ( it == SingletonCreatorFcns.end() ) {
61 |     return NULL;
62 |   }
63 |   return (it->second);
64 | }
65 | 
66 | template 
67 | std::vector SingletonFactory::getNames( ) const {
68 |   std::vector names;
69 |   for (auto entry : SingletonCreatorFcns ) {
70 |     names.push_back( entry.first );
71 |   }
72 |   return names;
73 | }
74 | 
75 | template 
76 | SingletonFactory& SingletonFactory::getInstance(){
77 |   static SingletonFactory theFactory;
78 |   return theFactory;
79 | }
80 | 
81 | #endif
82 | 


--------------------------------------------------------------------------------
/ImageProc/processor_sobel.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | #include "include/rapidjson/document.h"
 5 | 
 6 | // OpenCV Sobel Derivative example from doc
 7 | // http://docs.opencv.org/doc/tutorials/imgtrans/sobel_derivatives/sobel_derivaties.html
 8 | class SobelProcessor : public Processor {
 9 |   public:
10 |     cv::Mat operator()(cv::Mat);
11 |     void init(const char*);
12 |     std::string getParameters();
13 |   private:
14 |     static void createOutput(cv::Mat&, cv::Mat&);
15 |     int ksize = CV_SCHARR;
16 | };
17 | 
18 | cv::Mat SobelProcessor::operator()(cv::Mat im) {
19 |  
20 |   cv::Mat grey;
21 |   // Remove noise by blurring with Gaussian
22 |   cv::GaussianBlur(im, im, cv::Size(3,3), 0,0, cv::BORDER_DEFAULT);
23 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
24 |   
25 |   int scale = 1;
26 |   int delta = 0;
27 |   int ddepth = CV_16S;
28 |   cv::Mat gradX;
29 |   cv::Sobel(grey, gradX, ddepth, 1, 0, ksize, scale, delta, cv::BORDER_DEFAULT);
30 |   cv::Mat gradY;
31 |   cv::Sobel(grey, gradY, ddepth, 0, 1, ksize, scale, delta, cv::BORDER_DEFAULT);
32 | 
33 |   // Scaled abs gradients
34 |   cv::Mat gradMag;
35 |   cv::addWeighted(gradX, 0.5, gradY, 0.5, 0, gradMag);
36 |   
37 |   double maxVal;
38 |   cv::minMaxLoc( gradMag, NULL, &maxVal);
39 |   cv::Mat gradient;
40 |   cv::convertScaleAbs( gradMag*(255/maxVal), gradient );
41 | 
42 |   // Display intermediate images for debugging
43 |   cv::Mat dest;
44 |   createOutput( gradient, dest );
45 |   return dest; 
46 | }
47 | 
48 | void SobelProcessor::init(const char* json) {
49 |   // Read json string to set properties
50 |   using namespace rapidjson;
51 |   Document document;
52 |   document.Parse(json);
53 |   assert(document.IsObject());
54 |   assert(document.HasMember("ksize"));
55 |   ksize = document["ksize"].GetInt();
56 | }
57 | 
58 | std::string SobelProcessor::getParameters() {
59 |   std::ostringstream os;
60 |   os <<  "{\"ksize\":" << ksize << "}";
61 |   return os.str();
62 | }
63 | 
64 | void SobelProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
65 | {
66 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
67 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
68 |   std::vector rgba_out;
69 |   rgba_out.push_back( src );
70 |   rgba_out.push_back( src );
71 |   rgba_out.push_back( src );
72 |   rgba_out.push_back( fullAlpha );
73 | 
74 |   cv::merge( rgba_out, dest);
75 | }
76 | 
77 | namespace {
78 |   auto scProcReg = ProcessorRegister("Sobel Derivative");
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/Simple/simple_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style license that can be
 3 | // found in the LICENSE file.
 4 | 
 5 | #include 
 6 | #include 
 7 | #include 
 8 | 
 9 | #include "ppapi_simple/ps_interface.h"
10 | #include "ppapi_simple/ps_main.h"
11 | 
12 | // The main object that runs SimpleTemplate simulation.
13 | class SimpleTemplate {
14 |  public:
15 |   SimpleTemplate();
16 |   virtual ~SimpleTemplate() {};
17 |   // Handle event from user, or message from JS.
18 |   void HandleEvent(PSEvent* ps_event);
19 |   bool isRunning() { return !quit_; };
20 | 
21 |  private:
22 |   // Helper to post small update messages to JS.
23 |   void PostUpdateMessage(const char* message_name, double value);
24 |   bool quit_;
25 | 
26 | };
27 | 
28 | SimpleTemplate::SimpleTemplate()  {
29 |   quit_ = false;
30 |   PSEventSetFilter(PSE_ALL);
31 | }
32 | 
33 | // Handle input events from the user and messages from JS.
34 | void SimpleTemplate::HandleEvent(PSEvent* ps_event) {
35 |   if (ps_event->type == PSE_INSTANCE_HANDLEMESSAGE) {
36 |     // Convert Pepper Simple message to PPAPI C++ var
37 |     pp::Var var(ps_event->as_var);
38 |     if (var.is_dictionary()) {
39 |       pp::VarDictionary dictionary(var);
40 |       std::string message = dictionary.Get("message").AsString();
41 |       if (message == "hello") {
42 |         printf("Hello world!\n");
43 |       }
44 |       else if (message == "quit") {
45 |         printf("Exiting\n");
46 |         quit_ = true;
47 |       }
48 |     }
49 |   }
50 | }
51 | 
52 | // PostUpdateMessage() helper function for sendimg small messages to JS.
53 | void SimpleTemplate::PostUpdateMessage(const char* message_name, double value) {
54 |   pp::VarDictionary message;
55 |   message.Set("message", message_name);
56 |   message.Set("value", value);
57 |   PSInterfaceMessaging()->PostMessage(PSGetInstanceId(), message.pp_var());
58 | }
59 | 
60 | // Starting point for the module.  We do not use main since it would
61 | // collide with main in libppapi_cpp.
62 | int app_main(int argc, char* argv[]) {
63 |   SimpleTemplate app;
64 | 
65 |   while (app.isRunning()) {
66 |     PSEvent* ps_event;
67 |     // Consume all available events.
68 |     while ((ps_event = PSEventTryAcquire()) != NULL) {
69 |       app.HandleEvent(ps_event);
70 |       PSEventRelease(ps_event);
71 |     }
72 |   }
73 | 
74 |   return 0;
75 | }
76 | 
77 | // Register the function to call once the Instance Object is initialized.
78 | // see: pappi_simple/ps_main.h
79 | PPAPI_SIMPLE_REGISTER_MAIN(app_main);
80 | 


--------------------------------------------------------------------------------
/MonteCarlo/monte_carlo.cpp:
--------------------------------------------------------------------------------
 1 | #include "mc_instance.hpp"
 2 | #include "singleton_factory.hpp"
 3 | #include 
 4 | #include 
 5 | #include 
 6 | 
 7 | pp::Module* pp::CreateModule() {
 8 |   return new InstanceFactory();
 9 | }
10 | 
11 | void MonteCarloInstance::Simulate( int32_t /*result*/,  
12 |         std::function model, unsigned int N) {
13 |   // Run the simulation in 10 parts or max 1e6 points at a time
14 |   const len_t nParts = 10;
15 |   auto step = N/nParts;
16 |   step = step > 0 ? step : 1;
17 |   step = step < 1e6 ? step : 1e6;
18 |   len_t runningTotal = 0;
19 |   unsigned int count=0;
20 |   for( len_t i=step; i<=N; i += step) {
21 |     if ( run_simulation_ ) {
22 |       auto res = mc.sim(model, step);
23 |       runningTotal += res.Total;
24 |       auto outData = PostResponse( runningTotal, i);
25 |       count++;
26 |     }
27 |   }
28 |   pp::VarDictionary msg;
29 |   msg.Set( "Type", "completed" );
30 |   PostMessage( msg );
31 | }
32 | 
33 | pp::VarDictionary MonteCarloInstance::PostResponse( len_t runningTotal, len_t i){
34 |   pp::VarDictionary outData;
35 |   outData.Set( "Type", "partial" );
36 |   outData.Set( "Samples", static_cast(i) );
37 |   outData.Set( "Total", static_cast(runningTotal) );
38 |   auto runningMean = 1.0*runningTotal/i;
39 |   outData.Set( "Mean", runningMean );
40 |   outData.Set( "StdError", sqrt( runningMean*(1.0-runningMean)/i));
41 |   PostMessage( outData ); // For progress measurement
42 |   return outData;
43 | }
44 | 
45 | void MonteCarloInstance::HandleMessage( const pp::Var& var_message ) {
46 |   // Interface: receive a { cmd: ..., args... } dictionary  
47 |   // - sim, nPts = start simulation with that number of runs
48 |   // - receive anything else = stop the simulation
49 |   pp::VarDictionary var_dict( var_message );
50 |   auto cmd = var_dict.Get( "cmd" ).AsString();
51 |   if ( cmd == "sim" ) {
52 |     // Message is number of simulations to run
53 |     auto N = var_dict.Get("nPts").AsInt();
54 |     auto modelFactory = SingletonFactory>::getInstance();
55 |     auto model = modelFactory.getObject( var_dict.Get("model").AsString() );
56 |     // Enable simulation
57 |     run_simulation_ = true;
58 |     // Start simulation on background thread
59 |     sim_thread_.message_loop().PostWork( 
60 |         callback_factory_.NewCallback( &MonteCarloInstance::Simulate, model, N));
61 |   } else {
62 |     // Disable simulation - background thread will see this at start of
63 |     // next iteration and terminate early
64 |     run_simulation_ = false;
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/ImageProc/processor_barcode.cpp:
--------------------------------------------------------------------------------
 1 | #include "singleton_factory.hpp"
 2 | #include "opencv2/imgproc/imgproc.hpp"
 3 | #include 
 4 | 
 5 | class BarcodeDetectorProcessor : public Processor {
 6 |   public:
 7 |     cv::Mat operator()(cv::Mat);
 8 |   private:
 9 |     static void createOutput(cv::Mat&, cv::Mat&);
10 | };
11 | 
12 | cv::Mat BarcodeDetectorProcessor::operator()(cv::Mat im) {
13 |   cv::Mat grey;
14 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
15 |   cv::Mat gradX;
16 |   cv::Scharr(grey, gradX, CV_32F, 1, 0);
17 |   cv::Mat gradY;
18 |   cv::Scharr(grey, gradY, CV_32F, 0, 1);
19 |   cv::Mat gradient;
20 |   cv::subtract( gradX, gradY, gradient);
21 |   cv::convertScaleAbs(gradient, gradient);
22 | 
23 |   cv::Mat blurred;
24 |   cv::blur(gradient, blurred, cv::Size(9,9));
25 | 
26 |   cv::Mat thresh;
27 |   cv::threshold(gradient, thresh, 225, 255, cv::THRESH_BINARY );
28 | 
29 |   // Close image to convert barcode lines into filled rectangle
30 |   cv::Mat kernel = cv::getStructuringElement( 
31 |     cv::MORPH_RECT, cv::Size(21,7));
32 |   cv::Mat closed;
33 |   cv::morphologyEx( thresh, closed, cv::MORPH_CLOSE, kernel);
34 | 
35 |   // Remove small blobs
36 |   cv::erode( closed, closed, cv::Mat(), cv::Point(-1,1), 4);
37 |   cv::dilate( closed, closed, cv::Mat(), cv::Point(-1,1), 4);
38 | 
39 |   // Find largest area
40 |   std::vector> contours;
41 |   cv::findContours( closed, contours, cv::RETR_EXTERNAL, 
42 |     cv::CHAIN_APPROX_SIMPLE );
43 | 
44 |   std::sort(contours.begin(), contours.end(), 
45 |     [](const std::vector a, const std::vectorb) { 
46 |         return (cv::contourArea(a) > cv::contourArea(b)); });
47 |  
48 |   cv::RotatedRect rect = cv::minAreaRect( contours[0]);
49 |   cv::Point2f vertices[4];
50 |   rect.points( vertices );
51 |   for (int i=0; i<4; i++) {
52 |     cv::line( im, vertices[i], vertices[(i+1)%4], 
53 |       cv::Scalar(0,255,0,255), 3);
54 |   }
55 | 
56 |   // cv::drawContours( im, outContour, -1, cv::Scalar(0,255,0), 3);
57 | 
58 |   // Display intermediate images for debugging
59 |   // cv::Mat dest;
60 |   // createOutput( closed, dest );
61 |   return im; 
62 | }
63 | 
64 | void BarcodeDetectorProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
65 | {
66 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
67 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
68 |   std::vector rgba_out;
69 |   rgba_out.push_back( src );
70 |   rgba_out.push_back( src );
71 |   rgba_out.push_back( src );
72 |   rgba_out.push_back( fullAlpha );
73 | 
74 |   cv::merge( rgba_out, dest);
75 | }
76 | 
77 | namespace {
78 |   auto scProcReg = ProcessorRegister("Barcode Detector");
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/memorystream.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_MEMORYSTREAM_H_
16 | #define RAPIDJSON_MEMORYSTREAM_H_
17 | 
18 | #include "rapidjson.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | 
22 | //! Represents an in-memory input byte stream.
23 | /*!
24 |     This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
25 | 
26 |     It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
27 | 
28 |     Differences between MemoryStream and StringStream:
29 |     1. StringStream has encoding but MemoryStream is a byte stream.
30 |     2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
31 |     3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
32 |     \note implements Stream concept
33 | */
34 | struct MemoryStream {
35 |     typedef char Ch; // byte
36 | 
37 |     MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
38 | 
39 |     Ch Peek() const { return (src_ == end_) ? '\0' : *src_; }
40 |     Ch Take() { return (src_ == end_) ? '\0' : *src_++; }
41 |     size_t Tell() const { return static_cast(src_ - begin_); }
42 | 
43 |     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
44 |     void Put(Ch) { RAPIDJSON_ASSERT(false); }
45 |     void Flush() { RAPIDJSON_ASSERT(false); }
46 |     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
47 | 
48 |     // For encoding detection only.
49 |     const Ch* Peek4() const {
50 |         return Tell() + 4 <= size_ ? src_ : 0;
51 |     }
52 | 
53 |     const Ch* src_;     //!< Current read position.
54 |     const Ch* begin_;   //!< Original head of the string.
55 |     const Ch* end_;     //!< End of stream.
56 |     size_t size_;       //!< Size of the stream.
57 | };
58 | 
59 | RAPIDJSON_NAMESPACE_END
60 | 
61 | #endif // RAPIDJSON_MEMORYBUFFER_H_
62 | 


--------------------------------------------------------------------------------
/setup.txt:
--------------------------------------------------------------------------------
 1 | # Title: 'Install steps for OpenCV NaCl development on Ubuntu 14.04'
 2 | # Date: 20151104
 3 | # Author: Matt McDonnell (matt@matt-mcdonnell.com)
 4 | # Description: Steps for setting up a development environment for OpenCV
 5 | #   using Google Native Client (NaCl) on a bare Ubuntu 14.04 instance.
 6 | #   Tested on Amazon EC2 using a t2.micro instance running Ubuntu Server
 7 | #   14.04 LTS.  
 8 | #   
 9 | 
10 | # Install packages needed for NaCl SDK and naclports
11 | # Note that the NaCl SDK uses 32 bit versions of some libraries so these
12 | # need to be installed as well as the 64 bit versions.  If a particular
13 | # naclport fails to build check for missing 32 bit library first.
14 | sudo apt-get update
15 | sudo apt-get install unzip
16 | sudo apt-get install libc6-i386
17 | sudo apt-get install git
18 | sudo apt-get install build-essential
19 | sudo apt-get install lib32stdc++6
20 | sudo apt-get install cmake
21 | sudo apt-get install curl
22 | 
23 | # Install python
24 | # My preference is to use the Anaconda distribution
25 | # but apt-get will also work.
26 | 
27 | # Create directory structure for external code files (NaCl SDK, etc)
28 | # This directory structure is a personal preference so feel free to modify
29 | # (and change the paths in the rest of this script)
30 | mkdir Work
31 | mkdir Work/ExternCode
32 | cd Work/ExternCode/
33 | 
34 | # Install NaCl SDK
35 | curl -O https://storage.googleapis.com/nativeclient-mirror/nacl/nacl_sdk/nacl_sdk.zip
36 | unzip nacl_sdk.zip 
37 | cd nacl_sdk/
38 | ./naclsdk list
39 | ./naclsdk update
40 | 
41 | # Install depo-tools needed to install naclports
42 | cd ~/Work/ExternCode
43 | git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
44 | 
45 | # Add depot_tools to path and set NACL_SDK_ROOT
46 | vim ~/.bashrc 
47 | # Add lines below (without #) to .bashrc, modifying for location and SDK version if necessary
48 | # export PATH="/home/ubuntu/Work/ExternCode/depot_tools":"$PATH"
49 | # export NACL_SDK_ROOT="/home/ubuntu/Work/ExternCode/nacl_sdk/pepper_46/"
50 | exit # Logout and login again to pick up new environment settings
51 | 
52 | # Install NaCl ports 
53 | cd Work/ExternCode/
54 | mkdir naclports
55 | cd naclports/
56 | gclient config --name=src https://chromium.googlesource.com/webports
57 | gclient clean
58 | gclient sync
59 | cd src/
60 | # Set up git config with your name and email
61 | git config --global user.email "user@example.com"
62 | git config --global user.name "User Name"
63 | # Make opencv and dependencies (takes about 20 minutes)
64 | NACL_ARCH=pnacl make opencv
65 | 
66 | # (optional) Clone my NaCl demos
67 | cd
68 | cd Work/
69 | mkdir Projects
70 | cd Projects/
71 | git clone https://github.com/mattmcd/NaCl.git
72 | cd NaCl/ImageProc/
73 | make
74 | make serve # Expose port 8000 and try it out
75 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/memorybuffer.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_MEMORYBUFFER_H_
16 | #define RAPIDJSON_MEMORYBUFFER_H_
17 | 
18 | #include "rapidjson.h"
19 | #include "internal/stack.h"
20 | 
21 | RAPIDJSON_NAMESPACE_BEGIN
22 | 
23 | //! Represents an in-memory output byte stream.
24 | /*!
25 |     This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
26 | 
27 |     It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
28 | 
29 |     Differences between MemoryBuffer and StringBuffer:
30 |     1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
31 |     2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
32 | 
33 |     \tparam Allocator type for allocating memory buffer.
34 |     \note implements Stream concept
35 | */
36 | template 
37 | struct GenericMemoryBuffer {
38 |     typedef char Ch; // byte
39 | 
40 |     GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
41 | 
42 |     void Put(Ch c) { *stack_.template Push() = c; }
43 |     void Flush() {}
44 | 
45 |     void Clear() { stack_.Clear(); }
46 |     void ShrinkToFit() { stack_.ShrinkToFit(); }
47 |     Ch* Push(size_t count) { return stack_.template Push(count); }
48 |     void Pop(size_t count) { stack_.template Pop(count); }
49 | 
50 |     const Ch* GetBuffer() const {
51 |         return stack_.template Bottom();
52 |     }
53 | 
54 |     size_t GetSize() const { return stack_.GetSize(); }
55 | 
56 |     static const size_t kDefaultCapacity = 256;
57 |     mutable internal::Stack stack_;
58 | };
59 | 
60 | typedef GenericMemoryBuffer<> MemoryBuffer;
61 | 
62 | //! Implement specialized version of PutN() with memset() for better performance.
63 | template<>
64 | inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
65 |     std::memset(memoryBuffer.stack_.Push(n), c, n * sizeof(c));
66 | }
67 | 
68 | RAPIDJSON_NAMESPACE_END
69 | 
70 | #endif // RAPIDJSON_MEMORYBUFFER_H_
71 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/ieee754.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_IEEE754_
16 | #define RAPIDJSON_IEEE754_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | class Double {
24 | public:
25 |     Double() {}
26 |     Double(double d) : d_(d) {}
27 |     Double(uint64_t u) : u_(u) {}
28 | 
29 |     double Value() const { return d_; }
30 |     uint64_t Uint64Value() const { return u_; }
31 | 
32 |     double NextPositiveDouble() const {
33 |         RAPIDJSON_ASSERT(!Sign());
34 |         return Double(u_ + 1).Value();
35 |     }
36 | 
37 |     bool Sign() const { return (u_ & kSignMask) != 0; }
38 |     uint64_t Significand() const { return u_ & kSignificandMask; }
39 |     int Exponent() const { return static_cast(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
40 | 
41 |     bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
42 |     bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
43 |     bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
44 |     bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
45 | 
46 |     uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
47 |     int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
48 |     uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
49 | 
50 |     static unsigned EffectiveSignificandSize(int order) {
51 |         if (order >= -1021)
52 |             return 53;
53 |         else if (order <= -1074)
54 |             return 0;
55 |         else
56 |             return (unsigned)order + 1074;
57 |     }
58 | 
59 | private:
60 |     static const int kSignificandSize = 52;
61 |     static const int kExponentBias = 0x3FF;
62 |     static const int kDenormalExponent = 1 - kExponentBias;
63 |     static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
64 |     static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
65 |     static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
66 |     static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
67 | 
68 |     union {
69 |         double d_;
70 |         uint64_t u_;
71 |     };
72 | };
73 | 
74 | } // namespace internal
75 | RAPIDJSON_NAMESPACE_END
76 | 
77 | #endif // RAPIDJSON_IEEE754_
78 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/filereadstream.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_FILEREADSTREAM_H_
16 | #define RAPIDJSON_FILEREADSTREAM_H_
17 | 
18 | #include "rapidjson.h"
19 | #include 
20 | 
21 | RAPIDJSON_NAMESPACE_BEGIN
22 | 
23 | //! File byte stream for input using fread().
24 | /*!
25 |     \note implements Stream concept
26 | */
27 | class FileReadStream {
28 | public:
29 |     typedef char Ch;    //!< Character type (byte).
30 | 
31 |     //! Constructor.
32 |     /*!
33 |         \param fp File pointer opened for read.
34 |         \param buffer user-supplied buffer.
35 |         \param bufferSize size of buffer in bytes. Must >=4 bytes.
36 |     */
37 |     FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
38 |         RAPIDJSON_ASSERT(fp_ != 0);
39 |         RAPIDJSON_ASSERT(bufferSize >= 4);
40 |         Read();
41 |     }
42 | 
43 |     Ch Peek() const { return *current_; }
44 |     Ch Take() { Ch c = *current_; Read(); return c; }
45 |     size_t Tell() const { return count_ + static_cast(current_ - buffer_); }
46 | 
47 |     // Not implemented
48 |     void Put(Ch) { RAPIDJSON_ASSERT(false); }
49 |     void Flush() { RAPIDJSON_ASSERT(false); } 
50 |     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
51 |     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
52 | 
53 |     // For encoding detection only.
54 |     const Ch* Peek4() const {
55 |         return (current_ + 4 <= bufferLast_) ? current_ : 0;
56 |     }
57 | 
58 | private:
59 |     void Read() {
60 |         if (current_ < bufferLast_)
61 |             ++current_;
62 |         else if (!eof_) {
63 |             count_ += readCount_;
64 |             readCount_ = fread(buffer_, 1, bufferSize_, fp_);
65 |             bufferLast_ = buffer_ + readCount_ - 1;
66 |             current_ = buffer_;
67 | 
68 |             if (readCount_ < bufferSize_) {
69 |                 buffer_[readCount_] = '\0';
70 |                 ++bufferLast_;
71 |                 eof_ = true;
72 |             }
73 |         }
74 |     }
75 | 
76 |     std::FILE* fp_;
77 |     Ch *buffer_;
78 |     size_t bufferSize_;
79 |     Ch *bufferLast_;
80 |     Ch *current_;
81 |     size_t readCount_;
82 |     size_t count_;  //!< Number of characters read
83 |     bool eof_;
84 | };
85 | 
86 | RAPIDJSON_NAMESPACE_END
87 | 
88 | #endif // RAPIDJSON_FILESTREAM_H_
89 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/filewritestream.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_FILEWRITESTREAM_H_
16 | #define RAPIDJSON_FILEWRITESTREAM_H_
17 | 
18 | #include "rapidjson.h"
19 | #include 
20 | 
21 | RAPIDJSON_NAMESPACE_BEGIN
22 | 
23 | //! Wrapper of C file stream for input using fread().
24 | /*!
25 |     \note implements Stream concept
26 | */
27 | class FileWriteStream {
28 | public:
29 |     typedef char Ch;    //!< Character type. Only support char.
30 | 
31 |     FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
32 |         RAPIDJSON_ASSERT(fp_ != 0);
33 |     }
34 | 
35 |     void Put(char c) { 
36 |         if (current_ >= bufferEnd_)
37 |             Flush();
38 | 
39 |         *current_++ = c;
40 |     }
41 | 
42 |     void PutN(char c, size_t n) {
43 |         size_t avail = static_cast(bufferEnd_ - current_);
44 |         while (n > avail) {
45 |             std::memset(current_, c, avail);
46 |             current_ += avail;
47 |             Flush();
48 |             n -= avail;
49 |             avail = static_cast(bufferEnd_ - current_);
50 |         }
51 | 
52 |         if (n > 0) {
53 |             std::memset(current_, c, n);
54 |             current_ += n;
55 |         }
56 |     }
57 | 
58 |     void Flush() {
59 |         if (current_ != buffer_) {
60 |             size_t result = fwrite(buffer_, 1, static_cast(current_ - buffer_), fp_);
61 |             if (result < static_cast(current_ - buffer_)) {
62 |                 // failure deliberately ignored at this time
63 |                 // added to avoid warn_unused_result build errors
64 |             }
65 |             current_ = buffer_;
66 |         }
67 |     }
68 | 
69 |     // Not implemented
70 |     char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
71 |     char Take() { RAPIDJSON_ASSERT(false); return 0; }
72 |     size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
73 |     char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
74 |     size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
75 | 
76 | private:
77 |     // Prohibit copy constructor & assignment operator.
78 |     FileWriteStream(const FileWriteStream&);
79 |     FileWriteStream& operator=(const FileWriteStream&);
80 | 
81 |     std::FILE* fp_;
82 |     char *buffer_;
83 |     char *bufferEnd_;
84 |     char *current_;
85 | };
86 | 
87 | //! Implement specialized version of PutN() with memset() for better performance.
88 | template<>
89 | inline void PutN(FileWriteStream& stream, char c, size_t n) {
90 |     stream.PutN(c, n);
91 | }
92 | 
93 | RAPIDJSON_NAMESPACE_END
94 | 
95 | #endif // RAPIDJSON_FILESTREAM_H_
96 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/stringbuffer.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_STRINGBUFFER_H_
16 | #define RAPIDJSON_STRINGBUFFER_H_
17 | 
18 | #include "rapidjson.h"
19 | 
20 | #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
21 | #include  // std::move
22 | #endif
23 | 
24 | #include "internal/stack.h"
25 | 
26 | RAPIDJSON_NAMESPACE_BEGIN
27 | 
28 | //! Represents an in-memory output stream.
29 | /*!
30 |     \tparam Encoding Encoding of the stream.
31 |     \tparam Allocator type for allocating memory buffer.
32 |     \note implements Stream concept
33 | */
34 | template 
35 | class GenericStringBuffer {
36 | public:
37 |     typedef typename Encoding::Ch Ch;
38 | 
39 |     GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
40 | 
41 | #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
42 |     GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
43 |     GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
44 |         if (&rhs != this)
45 |             stack_ = std::move(rhs.stack_);
46 |         return *this;
47 |     }
48 | #endif
49 | 
50 |     void Put(Ch c) { *stack_.template Push() = c; }
51 |     void Flush() {}
52 | 
53 |     void Clear() { stack_.Clear(); }
54 |     void ShrinkToFit() {
55 |         // Push and pop a null terminator. This is safe.
56 |         *stack_.template Push() = '\0';
57 |         stack_.ShrinkToFit();
58 |         stack_.template Pop(1);
59 |     }
60 |     Ch* Push(size_t count) { return stack_.template Push(count); }
61 |     void Pop(size_t count) { stack_.template Pop(count); }
62 | 
63 |     const Ch* GetString() const {
64 |         // Push and pop a null terminator. This is safe.
65 |         *stack_.template Push() = '\0';
66 |         stack_.template Pop(1);
67 | 
68 |         return stack_.template Bottom();
69 |     }
70 | 
71 |     size_t GetSize() const { return stack_.GetSize(); }
72 | 
73 |     static const size_t kDefaultCapacity = 256;
74 |     mutable internal::Stack stack_;
75 | 
76 | private:
77 |     // Prohibit copy constructor & assignment operator.
78 |     GenericStringBuffer(const GenericStringBuffer&);
79 |     GenericStringBuffer& operator=(const GenericStringBuffer&);
80 | };
81 | 
82 | //! String buffer with UTF8 encoding
83 | typedef GenericStringBuffer > StringBuffer;
84 | 
85 | //! Implement specialized version of PutN() with memset() for better performance.
86 | template<>
87 | inline void PutN(GenericStringBuffer >& stream, char c, size_t n) {
88 |     std::memset(stream.stack_.Push(n), c, n * sizeof(c));
89 | }
90 | 
91 | RAPIDJSON_NAMESPACE_END
92 | 
93 | #endif // RAPIDJSON_STRINGBUFFER_H_
94 | 


--------------------------------------------------------------------------------
/GettingStarted/index.html:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 |   
 9 | 
10 | 
11 | 
12 |   hello_tutorial
13 | 
14 |   
63 | 
64 | 
65 | 
66 |   
NaCl C++ Tutorial: Getting Started

67 |   

68 |     
81 |     

82 |       
87 | 
88 |       
92 |     

93 |   

94 | 
95 |   
Status NO-STATUS

96 | 
97 | 
98 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/pow10.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_POW10_
16 | #define RAPIDJSON_POW10_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | //! Computes integer powers of 10 in double (10.0^n).
24 | /*! This function uses lookup table for fast and accurate results.
25 |     \param n non-negative exponent. Must <= 308.
26 |     \return 10.0^n
27 | */
28 | inline double Pow10(int n) {
29 |     static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
30 |         1e+0,  
31 |         1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
32 |         1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
33 |         1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
34 |         1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
35 |         1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
36 |         1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
37 |         1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
38 |         1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
39 |         1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
40 |         1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
41 |         1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
42 |         1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
43 |         1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
44 |         1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
45 |         1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
46 |         1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
47 |     };
48 |     RAPIDJSON_ASSERT(n >= 0 && n <= 308);
49 |     return e[n];
50 | }
51 | 
52 | } // namespace internal
53 | RAPIDJSON_NAMESPACE_END
54 | 
55 | #endif // RAPIDJSON_POW10_
56 | 


--------------------------------------------------------------------------------
/ImageProc/README.md:
--------------------------------------------------------------------------------
 1 | Image Processing
 2 | ================
 3 | Image processing using Native Client.  The goal of this project is to use
 4 | the C++ OpenCV image processing library to do realtime image processing of
 5 | the webcam feed.
 6 | 
 7 | Implementation
 8 | --------------
 9 | Rough plan for next few commits:
10 | 
11 | - [x] Hidden HTML5 __video__ element sourced from navigator.getUserMedia (webcam).
12 | - [x] Canvas element samples video every 20ms and draws on the canvas.
13 | - [x] Send canvas image as ArrayBuffer to Native Client.
14 | - [x] NaCl echoes image that has been received.
15 | - [x] Javascript puts echoed image to __processed__ canvas.
16 | - [x] Start playing with OpenCV image processing.
17 | - [x] Use strategy pattern on the C++ side to register new image
18 |   processors.
19 | - [x] Modify NaCl getVersion interface to return list of available processors.
20 | - [x] Use returned list of processors to populate js list selector.
21 | - [ ] Get the [Pulse Detection](http://people.csail.mit.edu/mrub/vidmag/) filter working. 
22 | - [x] Get the [Detecting
23 |   Barcodes](http://www.pyimagesearch.com/2014/11/24/detecting-barcodes-images-python-opencv) demo working.
24 | - [x] Simple cartoon filter.
25 | - [x] Face detection.
26 | 
27 | [Try it out!](https://www.matt-mcdonnell.com/code/NaCl/ImageProc/index.html) - you may need 
28 | to clear the cache to see any updates.  To do this open Chrome Developer Tools (Ctrl-Shift-i or F12), 
29 | then click and hold Reload, choose "Empty Cache and Hard Reload" from the popup menu.  Popup menu may
30 | only appear if you have a cached page i.e. have previously visited.
31 | 
32 | Build Setup
33 | -----------
34 | UPDATED: Please see setup.txt in parent directory for a step by step setup on a new Ubuntu server.  
35 | 
36 | There are a few steps needed to configure in order to use OpenCV with NaCl.
37 | Fortunately, once you become aware of the existence of  [NaCl Ports](https://code.google.com/p/naclports/) 
38 | they are fairly straight forward.
39 | 
40 | 1. Install [Depo Tools](http://dev.chromium.org/developers/how-tos/install-depot-tools).
41 | 2. [Check out the NaCl Ports](https://code.google.com/p/naclports/wiki/HowTo_Checkout).
42 | 2. ~~Follow the [Install guide for SDL](https://code.google.com/p/naclports/wiki/InstallingSDL),
43 |    replacing __sdl__ with __opencv__ and choosing pnacl as the architecture to
44 |    build.~~
45 |    Seems like the original instructions have been deleted, and didn't cover
46 |    which branch to use in any event.  cd to the dir where you've checked
47 |    out nacl_ports (for me ~/Work/ExternCode/nacl_ports/src ) with depotools
48 |    then change to the branch that matches NACL_SDK_ROOT
49 | 
50 |     git checkout pepper_40 

51 |     NACL_ARCH=pnacl make opencv
52 | 
53 |    The build itself took about 15 minutes on my Intel i3 dual core laptop.
54 | 
55 | 3. Add the opencv libraries and zlib to the build arguments:
56 | 
57 |     LDFLAGS := -L$(NACL_SDK_ROOT)/lib/pnacl/Release -lppapi_cpp -lppapi -lopencv_core -lz
58 | 
59 | Updating NaCl and NaCl Ports
60 | ----------------------------
61 | NaCl updates on around the same release cycle as the Chrome browser.
62 | Chrome itself is backwards compatible but it's still a good idea to keep
63 | roughly up to date.
64 | 
65 | Here we assume that the NaCl SDK has been installed in NACL_ROOT
66 | (NACL_SDK_ROOT will be under this), and NaCl ports has been installed in
67 | PORTS_ROOT.  On my machine these are ~/Work/ExternCode/nacl_sdk and
68 | ~/Work/ExternCode/nacl_ports respectively.
69 | 
70 | 1. Update NaCl SDK
71 |    - cd NACL_ROOT
72 |    - ./naclsdk update
73 | 2. Update NACL_SDK_ROOT environment variable e.g. NACL_ROOT/pepper_41
74 | 3. Update ports
75 |    - cd PORTS_ROOT
76 |    - cd src
77 |    - git checkout -b pepper_41 origin/pepper_41
78 |    - gclient sync
79 |    - (If that fails, cd .. vim .gclient and set managed=False)
80 | 
81 | LICENSE
82 | -------
83 | BSD
84 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/error/en.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef RAPIDJSON_ERROR_EN_H__
16 | #define RAPIDJSON_ERROR_EN_H__
17 | 
18 | #include "error.h"
19 | 
20 | RAPIDJSON_NAMESPACE_BEGIN
21 | 
22 | //! Maps error code of parsing into error message.
23 | /*!
24 |     \ingroup RAPIDJSON_ERRORS
25 |     \param parseErrorCode Error code obtained in parsing.
26 |     \return the error message.
27 |     \note User can make a copy of this function for localization.
28 |         Using switch-case is safer for future modification of error codes.
29 | */
30 | inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
31 |     switch (parseErrorCode) {
32 |         case kParseErrorNone:                           return RAPIDJSON_ERROR_STRING("No error.");
33 | 
34 |         case kParseErrorDocumentEmpty:                  return RAPIDJSON_ERROR_STRING("The document is empty.");
35 |         case kParseErrorDocumentRootNotSingular:        return RAPIDJSON_ERROR_STRING("The document root must not follow by other values.");
36 |     
37 |         case kParseErrorValueInvalid:                   return RAPIDJSON_ERROR_STRING("Invalid value.");
38 |     
39 |         case kParseErrorObjectMissName:                 return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
40 |         case kParseErrorObjectMissColon:                return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
41 |         case kParseErrorObjectMissCommaOrCurlyBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
42 |     
43 |         case kParseErrorArrayMissCommaOrSquareBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
44 | 
45 |         case kParseErrorStringUnicodeEscapeInvalidHex:  return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
46 |         case kParseErrorStringUnicodeSurrogateInvalid:  return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
47 |         case kParseErrorStringEscapeInvalid:            return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
48 |         case kParseErrorStringMissQuotationMark:        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
49 |         case kParseErrorStringInvalidEncoding:          return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
50 | 
51 |         case kParseErrorNumberTooBig:                   return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
52 |         case kParseErrorNumberMissFraction:             return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
53 |         case kParseErrorNumberMissExponent:             return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
54 | 
55 |         case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
56 |         case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
57 | 
58 |         default:
59 |             return RAPIDJSON_ERROR_STRING("Unknown error.");
60 |     }
61 | }
62 | 
63 | RAPIDJSON_NAMESPACE_END
64 | 
65 | #endif // RAPIDJSON_ERROR_EN_H__
66 | 


--------------------------------------------------------------------------------
/ImageProc/url_loader_handler.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style license that can be
 3 | // found in the LICENSE file.
 4 | 
 5 | #ifndef URL_LOADER_HANDLER_H_
 6 | #define URL_LOADER_HANDLER_H_
 7 | 
 8 | #include 
 9 | #include "ppapi/cpp/completion_callback.h"
10 | #include "ppapi/cpp/instance.h"
11 | #include "ppapi/cpp/url_loader.h"
12 | #include "ppapi/cpp/url_request_info.h"
13 | #include "ppapi/utility/completion_callback_factory.h"
14 | #define READ_BUFFER_SIZE 32768
15 | 
16 | // URLLoaderHandler is used to download data from |url|. When download is
17 | // finished or when an error occurs, it posts a message back to the browser
18 | // with the results encoded in the message as a string and self-destroys.
19 | //
20 | // pp::URLLoader.GetDownloadProgress() is used to to allocate the memory
21 | // required for url_response_body_ before the download starts.  (This is not so
22 | // much of a performance improvement, but it saves some memory since
23 | // std::string.insert() typically grows the string's capacity by somewhere
24 | // between 50% to 100% when it needs more memory, depending on the
25 | // implementation.)  Other performance improvements made as outlined in this
26 | // bug: http://code.google.com/p/chromium/issues/detail?id=103947
27 | //
28 | // EXAMPLE USAGE:
29 | // URLLoaderHandler* handler* = URLLoaderHandler::Create(instance,url);
30 | // handler->Start();
31 | //
32 | class URLLoaderHandler {
33 |  public:
34 |   // Creates instance of URLLoaderHandler on the heap.
35 |   // URLLoaderHandler objects shall be created only on the heap (they
36 |   // self-destroy when all data is in).
37 |   static URLLoaderHandler* Create(pp::Instance* instance_,
38 |                                   const std::string& url);
39 |   // Initiates page (URL) download.
40 |   void Start();
41 | 
42 |  private:
43 |   URLLoaderHandler(pp::Instance* instance_, const std::string& url);
44 |   ~URLLoaderHandler();
45 | 
46 |   // Callback for the pp::URLLoader::Open().
47 |   // Called by pp::URLLoader when response headers are received or when an
48 |   // error occurs (in response to the call of pp::URLLoader::Open()).
49 |   // Look at  and
50 |   //  for more information about pp::URLLoader.
51 |   void OnOpen(int32_t result);
52 | 
53 |   // Callback for the pp::URLLoader::ReadResponseBody().
54 |   // |result| contains the number of bytes read or an error code.
55 |   // Appends data from this->buffer_ to this->url_response_body_.
56 |   void OnRead(int32_t result);
57 | 
58 |   // Reads the response body (asynchronously) into this->buffer_.
59 |   // OnRead() will be called when bytes are received or when an error occurs.
60 |   void ReadBody();
61 | 
62 |   // Append data bytes read from the URL onto the internal buffer.  Does
63 |   // nothing if |num_bytes| is 0.
64 |   void AppendDataBytes(const char* buffer, int32_t num_bytes);
65 | 
66 |   // Post a message back to the browser with the download results.
67 |   void ReportResult(const std::string& fname,
68 |                     const std::string& text,
69 |                     bool success);
70 |   // Post a message back to the browser with the download results and
71 |   // self-destroy.  |this| is no longer valid when this method returns.
72 |   void ReportResultAndDie(const std::string& fname,
73 |                           const std::string& text,
74 |                           bool success);
75 | 
76 |   pp::Instance* instance_;  // Weak pointer.
77 |   std::string url_;         // URL to be downloaded.
78 |   pp::URLRequestInfo url_request_;
79 |   pp::URLLoader url_loader_;  // URLLoader provides an API to download URLs.
80 |   char* buffer_;              // Temporary buffer for reads.
81 |   std::string url_response_body_;  // Contains accumulated downloaded data.
82 |   pp::CompletionCallbackFactory cc_factory_;
83 | 
84 |   URLLoaderHandler(const URLLoaderHandler&);
85 |   void operator=(const URLLoaderHandler&);
86 | };
87 | 
88 | #endif  // URL_LOADER_HANDLER_H_
89 | 


--------------------------------------------------------------------------------
/ImageProc/video_img.js:
--------------------------------------------------------------------------------
  1 | function make_image_source(useVideo, fileList) {
  2 | 
  3 |   var videoSourceId;
  4 |   var selectedSource;
  5 | 
  6 |   var imageData;
  7 |   
  8 |   function getVideoSources(cbFun) {
  9 |     // Populate list of video sources e.g. laptop camera and USB webcam
 10 |     MediaStreamTrack.getSources( 
 11 |       function( srcInfo ) {
 12 |         videoSourceId = srcInfo
 13 |           .filter( function(s) { return s.kind == "video"; } );
 14 |         selectedSource = videoSourceId[0].id;
 15 |         if (typeof cbFun !== 'undefined') {
 16 |           cbFun(videoSourceId);
 17 |         }
 18 |       } 
 19 |     );
 20 |   }
 21 | 
 22 |   function setVideoInput(cbFun) {
 23 |     navigator.webkitGetUserMedia(
 24 |       {video: { optional:[{sourceId : selectedSource}] }, audio:false}, 
 25 |       cbFun, 
 26 |       function (err) {
 27 |         console.log("Unable to get media stream:" + err.Code );
 28 |       });
 29 |   }
 30 |   
 31 |   return {
 32 |     init : getVideoSources,
 33 |     getSourceIds : function(){ return videoSourceId; },
 34 |     setSource : function(srcId) { selectedSource = srcId;},
 35 |     getSource : function() { return selectedSource;},
 36 |     setVideoInput: setVideoInput
 37 |   }
 38 | }
 39 | 
 40 | function make_image_source_view(image_source) {
 41 |   // DOM nodes
 42 |   var videoSelect;
 43 |   var video;
 44 |   var display;
 45 |   var context; 
 46 | 
 47 |   var src = image_source;
 48 |   var samplePeriod = 40; // ms
 49 |   var averageFramePeriod = samplePeriod;
 50 |   var ewmaSmooth = 0.3;
 51 |   
 52 |   var isRunning = false;
 53 |   var isReadyToReceive = false;
 54 |   
 55 |   function setVideoCb () {
 56 |     console.log("camera changed from " + 
 57 |       src.getSource() + " to " + videoSelect.value);
 58 |     src.setSource(videoSelect.value);
 59 |     src.setVideoInput(drawCb);
 60 |   }
 61 |   
 62 |   function drawCb(stream) {
 63 |     video.src = window.URL.createObjectURL(stream);
 64 |     start();
 65 |   }
 66 | 
 67 |   function start() {
 68 |     isRunning = true;
 69 |     draw();
 70 |   }
 71 |   
 72 |   function draw() {
 73 |     if (!isRunning) return; // Early exit
 74 |     // Draw from video v to canvas context c
 75 |     context.drawImage(video, 0, 0);
 76 |     setTimeout( draw, samplePeriod, video, context);
 77 |   }
 78 |   
 79 |   function setVideoSelectList(videoSourceId) {
 80 |     videoSourceId.map( function(s, ind) { 
 81 |             // Set up list of cameras
 82 |             var option = document.createElement( "option" );
 83 |             option.text = "camera " + ind;
 84 |             option.value= s.id;
 85 |             videoSelect.appendChild( option );
 86 |             return s.id; } );
 87 |     setVideoCb();
 88 |     videoSelect.onchange = setVideoCb;
 89 |     videoSelect.hidden = false;
 90 |   }
 91 |   
 92 |   function getImageData( id ) {
 93 |     // Get image data from specified canvas
 94 |     var cv; 
 95 |     if (typeof id === 'undefined') {
 96 |       cv = display;
 97 |     } else {
 98 |       cv = document.getElementById( id );
 99 |     }
100 |     var ctx = cv.getContext( "2d" );
101 |     var height = cv.height;
102 |     var width = cv.width;
103 |     var nBytes = height * width * 4; 
104 |     var pixels = ctx.getImageData(0, 0, width, height);
105 |     var imData = { width: width, height: height, 
106 |       data: pixels.data.buffer };
107 |     return imData;
108 |   }
109 |  
110 |   function initControls(videoId, canvasId, selectId) {
111 |   // DOM Nodes for controls
112 |     video = document.getElementById( videoId );
113 |     display = document.getElementById( canvasId );
114 |     videoSelect = document.getElementById( selectId );
115 |     context = display.getContext("2d");
116 |     src.init(setVideoSelectList);
117 |   }
118 | 
119 |   return {
120 |     init: initControls,
121 |     stop: function() { isRunning = false; },
122 |     start: start,
123 |     setSamplePeriod: function (period) { 
124 |       samplePeriod = Math.max(period,0); },
125 |     getSamplePeriod: function () { return samplePeriod; },
126 |     getImageData: getImageData, 
127 |     isRunning: function() { return isRunning; }
128 |   }
129 | 
130 | }
131 | 


--------------------------------------------------------------------------------
/ImageProc/image_proc.cpp:
--------------------------------------------------------------------------------
  1 | #include "improc_instance.hpp"
  2 | #include "singleton_factory.hpp"
  3 | #include "url_loader_handler.hpp"
  4 | #include 
  5 | #include 
  6 | #include 
  7 | 
  8 | pp::Module* pp::CreateModule() 
  9 | {
 10 |   return new InstanceFactory();
 11 | }
 12 | 
 13 | void ImageProcInstance::Process( cv::Mat im) 
 14 | {
 15 |   auto result = (*processor)( im );
 16 |   auto nBytes = result.elemSize() * result.total();
 17 |   pp::VarDictionary msg;
 18 |   pp::VarArrayBuffer data(nBytes);
 19 |   uint8_t* copy = static_cast( data.Map());
 20 |   memcpy( copy, result.data, nBytes );
 21 | 
 22 |   msg.Set( "Type", "completed" );
 23 |   msg.Set( "Data", data );
 24 |   msg.Set( "Parameters", processor->getParameters());
 25 |   PostMessage( msg );
 26 | }
 27 | 
 28 | void ImageProcInstance::PostTest() 
 29 | {
 30 |   pp::VarDictionary msg;
 31 |   msg.Set( "Type", "completed" );
 32 |   msg.Set( "Data", "Processed ok" );
 33 |   PostMessage( msg );
 34 | }
 35 | 
 36 | void ImageProcInstance::SendStatus(const std::string& status) 
 37 | {
 38 |   pp::VarDictionary msg;
 39 |   msg.Set( "Type", "status" );
 40 |   msg.Set( "Message", status );
 41 |   PostMessage( msg );
 42 | }
 43 | 
 44 | 
 45 | void ImageProcInstance::HandleMessage( const pp::Var& var_message ) 
 46 | {
 47 |   // Interface: receive a { cmd: ..., args... } dictionary  
 48 |   pp::VarDictionary var_dict( var_message );
 49 |   auto cmd = var_dict.Get( "cmd" ).AsString();
 50 |   if ( cmd == "process" ) {
 51 | 
 52 |     // Message is number of simulations to run
 53 |     auto width  = var_dict.Get("width").AsInt();
 54 |     auto height = var_dict.Get("height").AsInt();
 55 |     auto data   = pp::VarArrayBuffer( var_dict.Get("data") );
 56 |     auto selectedProcessor = var_dict.Get("processor").AsString();
 57 |     bool newProcessor = selectedProcessor != processorName;
 58 |     if ( newProcessor ) {
 59 |       SendStatus("Creating processor factory");
 60 |       auto processorFactory = SingletonFactory<
 61 |         std::function()> >::getInstance();
 62 |       SendStatus("Creating processor");
 63 |       processor = processorFactory.getObject( selectedProcessor )();
 64 |       processorName = selectedProcessor;
 65 |     } else {
 66 |       SendStatus("Reusing processor");
 67 |     }
 68 |     // Convert data to CMat
 69 |     // SendStatus("Casting to byte array");
 70 |     uint8_t* byteData = static_cast(data.Map());
 71 |     // SendStatus("Creating cv::Mat");
 72 |     auto Img = cv::Mat(height, width, CV_8UC4, byteData );
 73 |     // SendStatus("Calling processing");
 74 |     
 75 |     // Special case: Smiley
 76 |     if ( (selectedProcessor == "Smiley!") && newProcessor ) {
 77 |       // Only send the image data for overlay on the first time we change
 78 |       // processor
 79 |       pp::VarDictionary sm_var_dict( var_dict.Get( "args" ));
 80 |       auto sm_width  = sm_var_dict.Get("width").AsInt();
 81 |       auto sm_height = sm_var_dict.Get("height").AsInt();
 82 |       auto sm_data   = pp::VarArrayBuffer( sm_var_dict.Get("data") );
 83 |       uint8_t* sm_byteData = static_cast(sm_data.Map());
 84 |       auto sm_Img = cv::Mat(sm_height, sm_width, CV_8UC4, sm_byteData );
 85 |       processor->init( sm_Img );
 86 |     } else if ( var_dict.HasKey( "args" ) ) {
 87 |       // Args key is json string that processor will parse
 88 |       auto json = var_dict.Get("args").AsString();
 89 |       processor->init( json.c_str() );
 90 |     }
 91 |     Process( Img );
 92 |   } else if ( cmd == "test" ) {
 93 |     PostTest();
 94 |   } else if ( cmd == "echo" ) {
 95 |       auto data = pp::VarArrayBuffer( var_dict.Get("data") );
 96 |       // auto result = data.is_array_buffer();
 97 |       pp::VarDictionary msg;
 98 |       msg.Set( "Type", "completed" );
 99 |       msg.Set( "Data", data );
100 |       PostMessage( msg );
101 |   } else if ( cmd == "load" ) {
102 |     // Load resource URL
103 |     auto url = var_dict.Get( "url" ).AsString();
104 |     URLLoaderHandler* handler = URLLoaderHandler::Create(this, url);
105 |     if (handler != NULL) {
106 |       // Starts asynchronous download. When download is finished or when an
107 |       // error occurs, |handler| posts the results back to the browser
108 |       // vis PostMessage and self-destroys.
109 |       handler->Start();
110 |     }
111 |   } else {
112 |     // Disable simulation - background thread will see this at start of
113 |     // next iteration and terminate early
114 |     run_simulation_ = false;
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/GettingStarted/hello_tutorial.cc:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style license that can be
 3 | // found in the LICENSE file.
 4 | 
 5 | /// @file hello_tutorial.cc
 6 | /// This example demonstrates loading, running and scripting a very simple NaCl
 7 | /// module.  To load the NaCl module, the browser first looks for the
 8 | /// CreateModule() factory method (at the end of this file).  It calls
 9 | /// CreateModule() once to load the module code.  After the code is loaded,
10 | /// CreateModule() is not called again.
11 | ///
12 | /// Once the code is loaded, the browser calls the CreateInstance()
13 | /// method on the object returned by CreateModule().  It calls CreateInstance()
14 | /// each time it encounters an  tag that references your NaCl module.
15 | ///
16 | /// The browser can talk to your NaCl module via the postMessage() Javascript
17 | /// function.  When you call postMessage() on your NaCl module from the browser,
18 | /// this becomes a call to the HandleMessage() method of your pp::Instance
19 | /// subclass.  You can send messages back to the browser by calling the
20 | /// PostMessage() method on your pp::Instance.  Note that these two methods
21 | /// (postMessage() in Javascript and PostMessage() in C++) are asynchronous.
22 | /// This means they return immediately - there is no waiting for the message
23 | /// to be handled.  This has implications in your program design, particularly
24 | /// when mutating property values that are exposed to both the browser and the
25 | /// NaCl module.
26 | 
27 | #include "ppapi/cpp/instance.h"
28 | #include "ppapi/cpp/module.h"
29 | #include "ppapi/cpp/var.h"
30 | 
31 | namespace {
32 |   // The expected string sent by the browser
33 |   const std::string kHelloString( "hello" );
34 |   // The string sent back to the browser in response to hello
35 |   const std::string kReplyString("Hello from NaCl!");
36 | }
37 | 
38 | /// The Instance class.  One of these exists for each instance of your NaCl
39 | /// module on the web page.  The browser will ask the Module object to create
40 | /// a new Instance for each occurrence of the  tag that has these
41 | /// attributes:
42 | ///     src="hello_tutorial.nmf"
43 | ///     type="application/x-pnacl"
44 | /// To communicate with the browser, you must override HandleMessage() to
45 | /// receive messages from the browser, and use PostMessage() to send messages
46 | /// back to the browser.  Note that this interface is asynchronous.
47 | class HelloTutorialInstance : public pp::Instance {
48 |  public:
49 |   /// The constructor creates the plugin-side instance.
50 |   /// @param[in] instance the handle to the browser-side plugin instance.
51 |   explicit HelloTutorialInstance(PP_Instance instance) : pp::Instance(instance)
52 |   {}
53 |   virtual ~HelloTutorialInstance() {}
54 | 
55 |   /// Handler for messages coming in from the browser via postMessage().  The
56 |   /// @a var_message can contain be any pp:Var type; for example int, string
57 |   /// Array or Dictinary. Please see the pp:Var documentation for more details.
58 |   /// @param[in] var_message The message posted by the browser.
59 |   virtual void HandleMessage(const pp::Var& var_message) {
60 |     // TODO(sdk_user): 1. Make this function handle the incoming message.
61 |     if ( !var_message.is_string())
62 |       return; // Early exit
63 |     // Convert from var string to std::string
64 |     // std::string message = var_message.AsString();
65 |     auto message = var_message.AsString();
66 |     if ( message == kHelloString ) {
67 |       pp::Var var_reply( kReplyString );
68 |       PostMessage( var_reply );
69 |     }
70 |   }
71 | };
72 | 
73 | /// The Module class.  The browser calls the CreateInstance() method to create
74 | /// an instance of your NaCl module on the web page.  The browser creates a new
75 | /// instance for each  tag with type="application/x-pnacl".
76 | class HelloTutorialModule : public pp::Module {
77 |  public:
78 |   HelloTutorialModule() : pp::Module() {}
79 |   virtual ~HelloTutorialModule() {}
80 | 
81 |   /// Create and return a HelloTutorialInstance object.
82 |   /// @param[in] instance The browser-side instance.
83 |   /// @return the plugin-side instance.
84 |   virtual pp::Instance* CreateInstance(PP_Instance instance) {
85 |     return new HelloTutorialInstance(instance);
86 |   }
87 | };
88 | 
89 | namespace pp {
90 | /// Factory function called by the browser when the module is first loaded.
91 | /// The browser keeps a singleton of this module.  It calls the
92 | /// CreateInstance() method on the object you return to make instances.  There
93 | /// is one instance per  tag on the page.  This is the main binding
94 | /// point for your NaCl module with the browser.
95 | Module* CreateModule() {
96 |   return new HelloTutorialModule();
97 | }
98 | }  // namespace pp
99 | 


--------------------------------------------------------------------------------
/ImageProc/processor_watershed.cpp:
--------------------------------------------------------------------------------
  1 | #include "singleton_factory.hpp"
  2 | #include "opencv2/imgproc/imgproc.hpp"
  3 | #include 
  4 | 
  5 | class WatershedProcessor : public Processor {
  6 |   public:
  7 |     cv::Mat operator()(cv::Mat);
  8 |   private:
  9 |     static void createOutput(cv::Mat&, cv::Mat&);
 10 | };
 11 | 
 12 | cv::Mat WatershedProcessor::operator()(cv::Mat im) {
 13 |   // Watershed segmentation demo from the OpenCV documentation
 14 |   cv::Mat grey;
 15 |   cv::cvtColor( im, im, CV_RGBA2BGR );
 16 |   cv::cvtColor( im, grey, CV_BGR2GRAY );
 17 | 
 18 |   // We look for dark objects on a light background, as the original demo
 19 |   // was designed for finding coins on a table.  The THRESH_OTSU flag makes
 20 |   // OpenCV choose the optimum threshold levels for a given image.
 21 |   cv::Mat thresh;
 22 |   cv::threshold(grey, thresh, 0, 255, 
 23 |     cv::THRESH_BINARY_INV + cv::THRESH_OTSU );
 24 |   
 25 |   // Open image to remove noise
 26 |   cv::Mat kernel = cv::getStructuringElement( 
 27 |     cv::MORPH_RECT, cv::Size(3,3));
 28 |   cv::Mat opening;
 29 |   cv::morphologyEx( thresh, opening, cv::MORPH_OPEN, 
 30 |     kernel, cv::Point(-1,1), 2);
 31 | 
 32 |   // Next we want to determine where the boundary between foreground and
 33 |   // background lies.  
 34 | 
 35 |   // Sure background area.  This is created by dilating the region we've
 36 |   // already highlighted.  Any point that is still 0 must be part of the
 37 |   // background.  Any highlighted point could be boundary or foreground.
 38 |   cv::Mat sureBg;
 39 |   cv::dilate( opening, sureBg, kernel, cv::Point(-1,1), 3);
 40 | 
 41 |   // Sure foreground area.  We apply a distance transform to give each
 42 |   // point a value that is its distance from the nearest 0.  This means
 43 |   // that points near the boundary of the thresholded image get a low
 44 |   // value, while ones further from the boundary get a higher value.
 45 |   cv::Mat distTfm;
 46 |   cv::distanceTransform( opening, distTfm, CV_DIST_L2, 5);
 47 |   cv::Mat sureFg;
 48 |   double minVal;
 49 |   double maxVal;
 50 |   cv::Point minLoc;
 51 |   cv::Point maxLoc;
 52 |   // Thresholding the distance transform image high lights areas far from
 53 |   // any boundary i.e. sure foreground features
 54 |   cv::minMaxLoc( distTfm, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() );
 55 |   cv::threshold( distTfm, sureFg, 0.7*maxVal, 255, 0);
 56 | 
 57 |   // Convert to 8 bit unsigned for further processing
 58 |   sureFg.convertTo( sureFg, CV_8U);
 59 | 
 60 |   // Unknown regions - parts of the sure background excluding areas we know
 61 |   // are the foreground regions.
 62 |   cv::Mat unknown;
 63 |   cv::subtract( sureBg, sureFg, unknown );
 64 | 
 65 |   // Now need to create a mask for the watershed algorithm.  We want to set
 66 |   // each foreground object to have a unique index, and give the background
 67 |   // another index.  The region we are unsure of gets labelled with 0.
 68 |   std::vector> contours;
 69 |   std::vector hierarchy;
 70 |   cv::findContours( sureFg, contours, hierarchy, cv::RETR_CCOMP, 
 71 |     cv::CHAIN_APPROX_SIMPLE );
 72 | 
 73 |   // Go through each foreground object and draw it to the marker matrix as
 74 |   // a differet positive integer.
 75 |   cv::Mat markers( sureFg.size(), CV_32S );
 76 |   int idx = 0;
 77 |   int compCount = 0;
 78 |   for (; idx >= 0; idx = hierarchy[idx][0], compCount++ ) {
 79 |     cv::drawContours( markers, contours, idx, cv::Scalar(compCount+1), 
 80 |     CV_FILLED, 8, hierarchy, INT_MAX );
 81 |   }
 82 |   // Set the marker for the background to be a different positive integer
 83 |   cv::add( markers, cv::Scalar(1), markers); // Non-zero background
 84 |   // Set all the unknown areas to 0.
 85 |   markers.setTo( cv::Scalar(0), unknown == 255 );
 86 | 
 87 |   // Watershed sets all of the markers == 0 points to the closest labelled
 88 |   // region, and marks the boundaries with a -1.
 89 |   cv::watershed( im, markers );
 90 |   // Highlight the boundaries on the original image
 91 |   im.setTo( cv::Scalar(0,0,255), markers == -1);
 92 | 
 93 |   // Used for displaying the final marker matrix
 94 |   // markers.convertTo( markers, CV_8U);
 95 | 
 96 |   // Display intermediate images for debugging
 97 |   // cv::Mat dest;
 98 |   // createOutput( markers, dest );
 99 |   cv::cvtColor( im, im, CV_BGR2RGBA );
100 |   return im; 
101 | }
102 | 
103 | void WatershedProcessor::createOutput( cv::Mat& src, cv::Mat& dest )
104 | {
105 |   // Show intermediate images - need to expand CV_8UC1 to RGBA
106 |   cv::Mat fullAlpha = cv::Mat( src.size(), CV_8UC1, cv::Scalar(255));
107 |   std::vector rgba_out;
108 |   rgba_out.push_back( src );
109 |   rgba_out.push_back( src );
110 |   rgba_out.push_back( src );
111 |   rgba_out.push_back( fullAlpha );
112 | 
113 |   cv::merge( rgba_out, dest);
114 | }
115 | 
116 | namespace {
117 |   auto scProcReg = ProcessorRegister("Watershed Segment");
118 | }
119 | 
120 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/license.txt:
--------------------------------------------------------------------------------
 1 | Tencent is pleased to support the open source community by making RapidJSON available. 
 2 |  
 3 | Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.  All rights reserved.
 4 | 
 5 | If you have downloaded a copy of the RapidJSON binary from Tencent, please note that the RapidJSON binary is licensed under the MIT License.
 6 | If you have downloaded a copy of the RapidJSON source code from Tencent, please note that RapidJSON source code is licensed under the MIT License, except for the third-party components listed below which are subject to different license terms.  Your integration of RapidJSON into your own projects may require compliance with the MIT License, as well as the other licenses applicable to the third-party components included within RapidJSON. To avoid the problematic JSON license in your own projects, it's sufficient to exclude the bin/jsonchecker/ directory, as it's the only code under the JSON license.
 7 | A copy of the MIT License is included in this file.
 8 | 
 9 | Other dependencies and licenses:
10 | 
11 | Open Source Software Licensed Under the BSD License:
12 | --------------------------------------------------------------------
13 | 
14 | The msinttypes r29 
15 | Copyright (c) 2006-2013 Alexander Chemeris 
16 | All rights reserved.
17 | 
18 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
19 | 
20 | * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
21 | * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
22 | * Neither the name of  copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
23 | 
24 | THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 
26 | Open Source Software Licensed Under the JSON License:
27 | --------------------------------------------------------------------
28 | 
29 | json.org 
30 | Copyright (c) 2002 JSON.org
31 | All Rights Reserved.
32 | 
33 | JSON_checker
34 | Copyright (c) 2002 JSON.org
35 | All Rights Reserved.
36 | 
37 | 	
38 | Terms of the JSON License:
39 | ---------------------------------------------------
40 | 
41 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
42 | 
43 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
44 | 
45 | The Software shall be used for Good, not Evil.
46 | 
47 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
48 | 
49 | 
50 | Terms of the MIT License:
51 | --------------------------------------------------------------------
52 | 
53 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
54 | 
55 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
56 | 
57 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
58 | 


--------------------------------------------------------------------------------
/MonteCarlo/mcView.js:
--------------------------------------------------------------------------------
  1 | // Global handle to module
  2 | var MonteCarloModule = null;
  3 | 
  4 | // Global status message
  5 | var statusText = 'NO-STATUS';
  6 | 
  7 | var lastClick = null;
  8 | 
  9 | var nPtsSim = null;
 10 | 
 11 | var results = new Array();
 12 | 
 13 | function pageDidLoad() {
 14 |   var listener = document.getElementById("listener");
 15 |   listener.addEventListener("load", moduleDidLoad, true );
 16 |   listener.addEventListener("message", handleMessage, true );
 17 |   if ( MonteCarloModule == null ) {
 18 |     updateStatus( 'LOADING...' );
 19 |   } else {
 20 |     updateStatus();
 21 |   }
 22 | }
 23 | 
 24 | function moduleDidLoad() {
 25 |   MonteCarloModule = document.getElementById( "monte_carlo" );
 26 |   updateStatus( "OK" );
 27 |   var go = document.getElementById( "go" );
 28 |   var nPts = document.getElementById( "nPts" );
 29 |   var modelList = document.getElementById( "model" );
 30 |   go.onclick = function() {
 31 |     nPtsSim = Number( nPts.value );
 32 |     console.log( "Sending " + nPtsSim);
 33 |     updateStatus( "Sending " + nPtsSim);
 34 |     lastClick = Date.now();
 35 |     // clear results
 36 |     results.length = 0;
 37 |     var model = modelList[ modelList.selectedIndex ].text;
 38 |     var cmd = { cmd: "sim", nPts: nPtsSim, model: model };
 39 |     MonteCarloModule.postMessage( cmd ); 
 40 |     updateControls_SimRunning();
 41 |     }; 
 42 |   // Stop button
 43 |   var stop = document.getElementById( "stop" );
 44 |   stop.onclick = function() {
 45 |     console.log( "Stop sent" );
 46 |     MonteCarloModule.postMessage( { cmd: "stop" } );
 47 |   }
 48 |   updateControls_SimStopped();
 49 | }
 50 | 
 51 | function handleMessage(message_event) {
 52 |   var res = message_event.data;
 53 |   if ( res.Type == "version" ) {
 54 |     updateStatus( res.Version );
 55 |     updateModels( res.Models );
 56 |   } else if ( res.Type == "partial" ) {
 57 |     var pctComplete = 100*res.Samples/nPtsSim;
 58 |     if ( Math.floor( pctComplete/10 ) > results.length ) {
 59 |       results[results.length] = res; // Add result to list of results
 60 |     }
 61 |     updateStatus( "Received: " + res.Mean.toFixed(7) 
 62 |         + " +/- " + res.StdError.toFixed(7) 
 63 |         + " after " + pctComplete.toFixed(1) + "% completion" );
 64 |   }
 65 |   if ( res.Type == "completed" ) {
 66 |     if ( results.length > 0 ) {
 67 |       // Show the full table and plot
 68 |       console.log( "Received " + results.length + " results" );
 69 |       var tDiff = Date.now() - lastClick;
 70 |       updateStatus( "Received: " + results[results.length-1].Mean.toFixed(7) 
 71 |           + " +/- " + results[results.length-1].StdError.toFixed(7) 
 72 |           +  " after " + tDiff + "ms" + " for " + results[results.length-1].Samples + " points" );
 73 |       updateTable( results );
 74 |       updatePlot( results );
 75 |     } else {
 76 |       // Simulation stopped before any data received
 77 |       updateStatus( "Stopped" );
 78 |     }
 79 |     updateControls_SimStopped();
 80 |   }
 81 | }
 82 | 
 83 | function updateStatus( optMessage ) {
 84 |   if (optMessage)
 85 |     statusText = optMessage;
 86 |   var statusField = document.getElementById("statusField");
 87 |   if (statusField) {
 88 |     statusField.innerHTML = " : " + statusText;
 89 |   }
 90 | }
 91 | 
 92 | function updateModels( models ) {
 93 |   // Add model names to listbox
 94 |   var modelList = d3.select("#model");
 95 |   var options = modelList.selectAll("option")
 96 |     .data( models ).enter().append("option")
 97 |     .text( function (d) {return d; });
 98 | }
 99 | 
100 | function updateTable( res ) {
101 |   // D3 visualization
102 |   d3.select("#results table").remove(); // Remove old data
103 |   var table = d3.select("#results").append("table");
104 |   var th = table.selectAll("th")
105 |     .data(["Samples","Total","Mean","Std Error"])
106 |     .enter().append("th").text( function (d) { return d; });
107 |   var tr = table.selectAll("tr")
108 |     .data( res )
109 |     .enter().append("tr");
110 |   var td = tr.selectAll("td")
111 |     .data( function (d) { 
112 |       return [d.Samples, d.Total, d.Mean.toFixed(7), d.StdError.toFixed(7)]; })
113 |     .enter().append("td");
114 |   td.text( function (d) { return d; });
115 | }
116 | 
117 | function updatePlot( res ){
118 |   d3.select("#plot svg").remove();
119 |   var w=320, h=200;
120 |   var x = d3.scale.linear().domain([0, res[res.length-1].Samples]).range( [0, w]);
121 |   var y = d3.scale.linear().domain([0, 1]).range([0, h]);
122 |   var chart = d3.select("#plot").append("svg").attr("width", w).attr("height", h);
123 |   var rect = chart.selectAll("rect").data( res );
124 |   var barWidth = 10;
125 |   rect.enter()
126 |     .append("rect")
127 |     .attr("x", function (d,i) { return x(d.Samples) - barWidth;})
128 |     .attr("y", function (d,i) { return h - y(d.Mean + d.StdError/2); })
129 |     .attr("width", function (d,i) { return barWidth; })
130 |     .attr("height", function (d,i) { return Math.max( y( d.StdError ), 1); })
131 |     .style("fill", "steelblue");
132 |   chart.append("line").attr("x1", 0).attr("x2",w).attr("y1",h).attr("y2",h).style("stroke","#000000");
133 |   chart.append("line").attr("x1", 0).attr("x2",0).attr("y1",h).attr("y2",0).style("stroke","#000000");
134 | }
135 | 
136 | function updateControls_SimRunning() {
137 |   d3.select("#results table").remove(); // Remove old data
138 |   d3.select("#plot svg").remove(); // Remove old data
139 |   var go = document.getElementById( "go" );
140 |   var nPts = document.getElementById( "nPts" );
141 |   var model = document.getElementById( "model" );
142 |   var stop = document.getElementById( "stop" );
143 |   go.disabled = true;
144 |   nPts.disabled = true;
145 |   model.disabled = true;
146 |   stop.disabled = false;
147 | }
148 | 
149 | function updateControls_SimStopped() {
150 |   var go = document.getElementById( "go" );
151 |   var nPts = document.getElementById( "nPts" );
152 |   var model = document.getElementById( "model" );
153 |   var stop = document.getElementById( "stop" );
154 |   go.disabled = false;
155 |   nPts.disabled = false;
156 |   model.disabled = false;
157 |   stop.disabled = true;
158 | }
159 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/error/error.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef RAPIDJSON_ERROR_ERROR_H__
 16 | #define RAPIDJSON_ERROR_ERROR_H__
 17 | 
 18 | #include "../rapidjson.h"
 19 | 
 20 | /*! \file error.h */
 21 | 
 22 | /*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
 23 | 
 24 | ///////////////////////////////////////////////////////////////////////////////
 25 | // RAPIDJSON_ERROR_CHARTYPE
 26 | 
 27 | //! Character type of error messages.
 28 | /*! \ingroup RAPIDJSON_ERRORS
 29 |     The default character type is \c char.
 30 |     On Windows, user can define this macro as \c TCHAR for supporting both
 31 |     unicode/non-unicode settings.
 32 | */
 33 | #ifndef RAPIDJSON_ERROR_CHARTYPE
 34 | #define RAPIDJSON_ERROR_CHARTYPE char
 35 | #endif
 36 | 
 37 | ///////////////////////////////////////////////////////////////////////////////
 38 | // RAPIDJSON_ERROR_STRING
 39 | 
 40 | //! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
 41 | /*! \ingroup RAPIDJSON_ERRORS
 42 |     By default this conversion macro does nothing.
 43 |     On Windows, user can define this macro as \c _T(x) for supporting both
 44 |     unicode/non-unicode settings.
 45 | */
 46 | #ifndef RAPIDJSON_ERROR_STRING
 47 | #define RAPIDJSON_ERROR_STRING(x) x
 48 | #endif
 49 | 
 50 | RAPIDJSON_NAMESPACE_BEGIN
 51 | 
 52 | ///////////////////////////////////////////////////////////////////////////////
 53 | // ParseErrorCode
 54 | 
 55 | //! Error code of parsing.
 56 | /*! \ingroup RAPIDJSON_ERRORS
 57 |     \see GenericReader::Parse, GenericReader::GetParseErrorCode
 58 | */
 59 | enum ParseErrorCode {
 60 |     kParseErrorNone = 0,                        //!< No error.
 61 | 
 62 |     kParseErrorDocumentEmpty,                   //!< The document is empty.
 63 |     kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
 64 | 
 65 |     kParseErrorValueInvalid,                    //!< Invalid value.
 66 | 
 67 |     kParseErrorObjectMissName,                  //!< Missing a name for object member.
 68 |     kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
 69 |     kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
 70 | 
 71 |     kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
 72 | 
 73 |     kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
 74 |     kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
 75 |     kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
 76 |     kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
 77 |     kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
 78 | 
 79 |     kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
 80 |     kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
 81 |     kParseErrorNumberMissExponent,              //!< Miss exponent in number.
 82 | 
 83 |     kParseErrorTermination,                     //!< Parsing was terminated.
 84 |     kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
 85 | };
 86 | 
 87 | //! Result of parsing (wraps ParseErrorCode)
 88 | /*!
 89 |     \ingroup RAPIDJSON_ERRORS
 90 |     \code
 91 |         Document doc;
 92 |         ParseResult ok = doc.Parse("[42]");
 93 |         if (!ok) {
 94 |             fprintf(stderr, "JSON parse error: %s (%u)",
 95 |                     GetParseError_En(ok.Code()), ok.Offset());
 96 |             exit(EXIT_FAILURE);
 97 |         }
 98 |     \endcode
 99 |     \see GenericReader::Parse, GenericDocument::Parse
100 | */
101 | struct ParseResult {
102 | 
103 |     //! Default constructor, no error.
104 |     ParseResult() : code_(kParseErrorNone), offset_(0) {}
105 |     //! Constructor to set an error.
106 |     ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
107 | 
108 |     //! Get the error code.
109 |     ParseErrorCode Code() const { return code_; }
110 |     //! Get the error offset, if \ref IsError(), 0 otherwise.
111 |     size_t Offset() const { return offset_; }
112 | 
113 |     //! Conversion to \c bool, returns \c true, iff !\ref IsError().
114 |     operator bool() const { return !IsError(); }
115 |     //! Whether the result is an error.
116 |     bool IsError() const { return code_ != kParseErrorNone; }
117 | 
118 |     bool operator==(const ParseResult& that) const { return code_ == that.code_; }
119 |     bool operator==(ParseErrorCode code) const { return code_ == code; }
120 |     friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
121 | 
122 |     //! Reset error code.
123 |     void Clear() { Set(kParseErrorNone); }
124 |     //! Update error code and offset.
125 |     void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
126 | 
127 | private:
128 |     ParseErrorCode code_;
129 |     size_t offset_;
130 | };
131 | 
132 | //! Function pointer type of GetParseError().
133 | /*! \ingroup RAPIDJSON_ERRORS
134 | 
135 |     This is the prototype for \c GetParseError_X(), where \c X is a locale.
136 |     User can dynamically change locale in runtime, e.g.:
137 | \code
138 |     GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
139 |     const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
140 | \endcode
141 | */
142 | typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
143 | 
144 | RAPIDJSON_NAMESPACE_END
145 | 
146 | #endif // RAPIDJSON_ERROR_ERROR_H__
147 | 


--------------------------------------------------------------------------------
/ImageProc/video.js:
--------------------------------------------------------------------------------
  1 | // Global handle to module
  2 | var ImageProcModule = null;
  3 | 
  4 | // Global status message
  5 | var statusText = 'NO-STATUS';
  6 | var lastClick = null;
  7 | 
  8 | var isRunning = false;
  9 | var isReadyToReceive = false;
 10 | 
 11 | var startTime;
 12 | var endTime;
 13 | var averageFramePeriod;
 14 | var ewmaSmooth = 0.3;
 15 | 
 16 | var videoSourceId;
 17 | var selectedSource;
 18 | 
 19 | var imageData;
 20 | var cachedSmiley;
 21 | 
 22 | var view;
 23 | 
 24 | // Parameters for current processor
 25 | var parameters;
 26 | 
 27 | function pageDidLoad() {
 28 |   var src = make_image_source();
 29 |   view = make_image_source_view(src);
 30 |   view.init("live", "display", "camera"); 
 31 |   var camera = document.getElementById("camera");
 32 |   camera.hidden = true;
 33 |   var listener = document.getElementById("listener");
 34 |   listener.addEventListener("load", moduleDidLoad, true );
 35 |   listener.addEventListener("message", handleMessage, true );
 36 |   if ( ImageProcModule == null ) {
 37 |     updateStatus( 'LOADING...' );
 38 |   } else {
 39 |     updateStatus();
 40 |   }
 41 | 
 42 | }
 43 | 
 44 | function loadResource() {
 45 |   var cmd = { cmd: "load",  
 46 |     url: "smiley_col.bmp" };
 47 |   ImageProcModule.postMessage( cmd );
 48 | }
 49 | 
 50 | function sendImage() {
 51 |   if ( isRunning && isReadyToReceive ) {
 52 |     // Get the current frame from canvas and send to NaCl
 53 |     // drawImage( pixels );
 54 |     var imData = view.getImageData();
 55 | 
 56 |     var theCommand = "process"; //"echo"; // test, process
 57 |     var selectedProcessor = getSelectedProcessor();
 58 |     var cmd = { cmd: theCommand,  
 59 |       width: imData.width, 
 60 |       height: imData.height, 
 61 |       data: imData.data, 
 62 |       processor: selectedProcessor };
 63 |     if ( selectedProcessor === "Smiley!" ) {
 64 |       cmd.args = cachedSmiley;
 65 |     } else if ( parameters ) {
 66 |       cmd.args = JSON.stringify( parameters );
 67 |     }
 68 |     startTime = performance.now();
 69 |     ImageProcModule.postMessage( cmd );
 70 |     isReadyToReceive = false; // Don't send any more frames until ready
 71 |   } else if (isRunning ) {
 72 |     // Do nothing
 73 |   } else { 
 74 |     updateStatus( 'Stopped' );
 75 |   }
 76 |   setTimeout( sendImage, view.getSamplePeriod() );
 77 | }
 78 | 
 79 | function drawImage(pixels){
 80 |     var processed = document.getElementById("processed");
 81 |     var ctx = processed.getContext( "2d" );
 82 |     var imData = ctx.getImageData(0,0,processed.width,processed.height);
 83 |     var buf8 = new Uint8ClampedArray( pixels );
 84 |     imData.data.set( buf8 );
 85 |     ctx.putImageData( imData, 0, 0);
 86 | }
 87 | 
 88 | function moduleDidLoad() {
 89 |   ImageProcModule = document.getElementById( "image_proc" );
 90 |   updateStatus( "OK" );
 91 |   // Load image resource
 92 |   // loadResource();
 93 |   var cv = document.getElementById( "smiley_canvas" );
 94 |   var ctx = cv.getContext( "2d" );
 95 |   var smiley = document.getElementById( "smiley" );
 96 |   ctx.drawImage(smiley, 0, 0);
 97 |   imageData = ctx.getImageData( 0, 0, smiley.width, smiley.height);
 98 |   cachedSmiley = view.getImageData("smiley_canvas");
 99 | 
100 |   var run = document.getElementById( "run" );
101 |   run.onclick = toggleSending;
102 | 
103 |   var stream = document.getElementById("stream");
104 |   stream.onclick = toggleStream;
105 |   stream.value = "On";
106 |   stream.textContent = stream.value;
107 |   stream.hidden = false;
108 | 
109 |   var camera = document.getElementById("camera");
110 |   camera.hidden = false;
111 |   run.hidden = false;
112 | }
113 | 
114 | function toggleStream() {
115 |   // Toggle input video stream on/off
116 |   var stream = document.getElementById("stream");
117 |   if (stream.value === 'On') {
118 |     // Stop camera
119 |     stream.value = 'Off';
120 |     view.stop();
121 |   } else {
122 |     // Start camera
123 |     stream.value = 'On';
124 |     view.start();
125 |   }
126 |   stream.textContent = stream.value;
127 | }
128 | 
129 | function toggleSending() {
130 |   var run = document.getElementById( "run" );
131 |   if (isRunning) {
132 |     // Stop processing
133 |     isRunning = false;
134 |     isReadyToReceive = false;
135 |     run.value = "Go";
136 |   } else {
137 |     // Start processing
138 |     isRunning = true;
139 |     isReadyToReceive = true;
140 |     run.value = "Stop";
141 |   }
142 |   run.textContent = run.value;
143 |   sendImage();
144 | }
145 | 
146 | function handleMessage(message_event) {
147 |   var res = message_event.data;
148 |   if ( res.Type == "version" ) {
149 |     updateStatus( res.Version );
150 |     updateProcessors( res.Processors );
151 |   }
152 |   if ( res.Type == "completed" ) {
153 |     if ( res.Data ) {
154 |       // updateStatus( "Received array buffer");
155 |       // Display processed image    
156 |       endTime = performance.now();
157 |       if (typeof averageFramePeriod === 'undefined' ) {
158 |         averageFramePeriod = view.getSamplePeriod();
159 |       }
160 |       averageFramePeriod = (1-ewmaSmooth)*averageFramePeriod + ewmaSmooth*(endTime-startTime);
161 |       updateStatus( 'Frame rate is ' + (averageFramePeriod).toFixed(1) + 'ms per frame' );
162 |       drawImage( res.Data );
163 |       isReadyToReceive = true;
164 |     } else {
165 |       updateStatus( "Received something unexpected");
166 |     }
167 |     if ( res.Parameters ) {
168 |       parameters = JSON.parse( res.Parameters );
169 |     } else {
170 |       parameters = "";
171 |     }
172 | 
173 |     // Display processed image    
174 |     //drawImage( res.Data );
175 |   }
176 |   if ( res.Type == "status" ) {
177 |     // updateStatus( res.Message ); 
178 |   }
179 |   if ( res.Type == "resource_loaded" ) {
180 |     // Load image from server
181 |     updateStatus( res.Message ); 
182 |     imageData = res.Data;
183 |   }
184 | }
185 | 
186 | function updateStatus( optMessage ) {
187 |   if (optMessage)
188 |     statusText = optMessage;
189 |   var statusField = document.getElementById("statusField");
190 |   if (statusField) {
191 |     statusField.innerHTML = " : " + statusText;
192 |   }
193 | }
194 | 
195 | function updateProcessors( processorNames ) {
196 |   var processors = document.getElementById( "processor" );
197 |   for (i=0; i
  6 | #include 
  7 | #include "ppapi/c/pp_errors.h"
  8 | #include "ppapi/c/ppb_instance.h"
  9 | #include "ppapi/cpp/module.h"
 10 | #include "ppapi/cpp/var.h"
 11 | #include "ppapi/cpp/var_dictionary.h"
 12 | #include "ppapi/cpp/file_io.h"
 13 | #include "ppapi/cpp/file_ref.h"
 14 | 
 15 | #include "url_loader_handler.hpp"
 16 | 
 17 | #ifdef WIN32
 18 | #undef min
 19 | #undef max
 20 | #undef PostMessage
 21 | 
 22 | // Allow 'this' in initializer list
 23 | #pragma warning(disable : 4355)
 24 | #endif
 25 | 
 26 | URLLoaderHandler* URLLoaderHandler::Create(pp::Instance* instance,
 27 |                                            const std::string& url) {
 28 |   return new URLLoaderHandler(instance, url);
 29 | }
 30 | 
 31 | URLLoaderHandler::URLLoaderHandler(pp::Instance* instance,
 32 |                                    const std::string& url)
 33 |     : instance_(instance),
 34 |       url_(url),
 35 |       url_request_(instance),
 36 |       url_loader_(instance),
 37 |       buffer_(new char[READ_BUFFER_SIZE]),
 38 |       cc_factory_(this) {
 39 |   url_request_.SetURL(url);
 40 |   url_request_.SetMethod("GET");
 41 |   url_request_.SetRecordDownloadProgress(true);
 42 | }
 43 | 
 44 | URLLoaderHandler::~URLLoaderHandler() {
 45 |   delete[] buffer_;
 46 |   buffer_ = NULL;
 47 | }
 48 | 
 49 | void URLLoaderHandler::Start() {
 50 |   pp::CompletionCallback cc =
 51 |       cc_factory_.NewCallback(&URLLoaderHandler::OnOpen);
 52 |   url_loader_.Open(url_request_, cc);
 53 | }
 54 | 
 55 | void URLLoaderHandler::OnOpen(int32_t result) {
 56 |   if (result != PP_OK) {
 57 |     ReportResultAndDie(url_, "pp::URLLoader::Open() failed", false);
 58 |     return;
 59 |   }
 60 |   // Here you would process the headers. A real program would want to at least
 61 |   // check the HTTP code and potentially cancel the request.
 62 |   // pp::URLResponseInfo response = loader_.GetResponseInfo();
 63 | 
 64 |   // Try to figure out how many bytes of data are going to be downloaded in
 65 |   // order to allocate memory for the response body in advance (this will
 66 |   // reduce heap traffic and also the amount of memory allocated).
 67 |   // It is not a problem if this fails, it just means that the
 68 |   // url_response_body_.insert() call in URLLoaderHandler::AppendDataBytes()
 69 |   // will allocate the memory later on.
 70 |   int64_t bytes_received = 0;
 71 |   int64_t total_bytes_to_be_received = 0;
 72 |   if (url_loader_.GetDownloadProgress(&bytes_received,
 73 |                                       &total_bytes_to_be_received)) {
 74 |     if (total_bytes_to_be_received > 0) {
 75 |       url_response_body_.reserve(total_bytes_to_be_received);
 76 |     }
 77 |   }
 78 |   // We will not use the download progress anymore, so just disable it.
 79 |   url_request_.SetRecordDownloadProgress(false);
 80 | 
 81 |   // Start streaming.
 82 |   ReadBody();
 83 | }
 84 | 
 85 | void URLLoaderHandler::AppendDataBytes(const char* buffer, int32_t num_bytes) {
 86 |   if (num_bytes <= 0)
 87 |     return;
 88 |   // Make sure we don't get a buffer overrun.
 89 |   num_bytes = std::min(READ_BUFFER_SIZE, num_bytes);
 90 |   // Note that we do *not* try to minimally increase the amount of allocated
 91 |   // memory here by calling url_response_body_.reserve().  Doing so causes a
 92 |   // lot of string reallocations that kills performance for large files.
 93 |   url_response_body_.insert(
 94 |       url_response_body_.end(), buffer, buffer + num_bytes);
 95 | }
 96 | 
 97 | void URLLoaderHandler::OnRead(int32_t result) {
 98 |   if (result == PP_OK) {
 99 |     // Streaming the file is complete, delete the read buffer since it is
100 |     // no longer needed.
101 |     delete[] buffer_;
102 |     buffer_ = NULL;
103 |     ReportResultAndDie(url_, url_response_body_, true);
104 |   } else if (result > 0) {
105 |     // The URLLoader just filled "result" number of bytes into our buffer.
106 |     // Save them and perform another read.
107 |     AppendDataBytes(buffer_, result);
108 |     ReadBody();
109 |   } else {
110 |     // A read error occurred.
111 |     ReportResultAndDie(
112 |         url_, "pp::URLLoader::ReadResponseBody() result<0", false);
113 |   }
114 | }
115 | 
116 | void URLLoaderHandler::ReadBody() {
117 |   // Note that you specifically want an "optional" callback here. This will
118 |   // allow ReadBody() to return synchronously, ignoring your completion
119 |   // callback, if data is available. For fast connections and large files,
120 |   // reading as fast as we can will make a large performance difference
121 |   // However, in the case of a synchronous return, we need to be sure to run
122 |   // the callback we created since the loader won't do anything with it.
123 |   pp::CompletionCallback cc =
124 |       cc_factory_.NewOptionalCallback(&URLLoaderHandler::OnRead);
125 |   int32_t result = PP_OK;
126 |   do {
127 |     result = url_loader_.ReadResponseBody(buffer_, READ_BUFFER_SIZE, cc);
128 |     // Handle streaming data directly. Note that we *don't* want to call
129 |     // OnRead here, since in the case of result > 0 it will schedule
130 |     // another call to this function. If the network is very fast, we could
131 |     // end up with a deeply recursive stack.
132 |     if (result > 0) {
133 |       AppendDataBytes(buffer_, result);
134 |     }
135 |   } while (result > 0);
136 | 
137 |   if (result != PP_OK_COMPLETIONPENDING) {
138 |     // Either we reached the end of the stream (result == PP_OK) or there was
139 |     // an error. We want OnRead to get called no matter what to handle
140 |     // that case, whether the error is synchronous or asynchronous. If the
141 |     // result code *is* COMPLETIONPENDING, our callback will be called
142 |     // asynchronously.
143 |     cc.Run(result);
144 |   }
145 | }
146 | 
147 | void URLLoaderHandler::ReportResultAndDie(const std::string& fname,
148 |                                           const std::string& text,
149 |                                           bool success) {
150 |   ReportResult(fname, text, success);
151 |   delete this;
152 | }
153 | 
154 | void URLLoaderHandler::ReportResult(const std::string& fname,
155 |                                     const std::string& text,
156 |                                     bool success) {
157 |   std::string status;
158 |   if (success) {
159 |     printf("URLLoaderHandler::ReportResult(Ok).\n");
160 |     status = "Loaded URL OK";
161 |   } else {
162 |     printf("URLLoaderHandler::ReportResult(Err). %s\n", text.c_str());
163 |     status = "URL load failed: " + text;
164 |   }
165 |   fflush(stdout);
166 |   if (instance_) {
167 |     pp::VarDictionary msg;
168 |     msg.Set( "Type", "resource_loaded" );
169 |     msg.Set( "Message", status );
170 |     msg.Set( "Data", text );
171 |     instance_->PostMessage( msg );
172 |   }
173 | }
174 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/stack.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef RAPIDJSON_INTERNAL_STACK_H_
 16 | #define RAPIDJSON_INTERNAL_STACK_H_
 17 | 
 18 | #include "../rapidjson.h"
 19 | #include "swap.h"
 20 | 
 21 | RAPIDJSON_NAMESPACE_BEGIN
 22 | namespace internal {
 23 | 
 24 | ///////////////////////////////////////////////////////////////////////////////
 25 | // Stack
 26 | 
 27 | //! A type-unsafe stack for storing different types of data.
 28 | /*! \tparam Allocator Allocator for allocating stack memory.
 29 | */
 30 | template 
 31 | class Stack {
 32 | public:
 33 |     // Optimization note: Do not allocate memory for stack_ in constructor.
 34 |     // Do it lazily when first Push() -> Expand() -> Resize().
 35 |     Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
 36 |         RAPIDJSON_ASSERT(stackCapacity > 0);
 37 |     }
 38 | 
 39 | #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 40 |     Stack(Stack&& rhs)
 41 |         : allocator_(rhs.allocator_),
 42 |           ownAllocator_(rhs.ownAllocator_),
 43 |           stack_(rhs.stack_),
 44 |           stackTop_(rhs.stackTop_),
 45 |           stackEnd_(rhs.stackEnd_),
 46 |           initialCapacity_(rhs.initialCapacity_)
 47 |     {
 48 |         rhs.allocator_ = 0;
 49 |         rhs.ownAllocator_ = 0;
 50 |         rhs.stack_ = 0;
 51 |         rhs.stackTop_ = 0;
 52 |         rhs.stackEnd_ = 0;
 53 |         rhs.initialCapacity_ = 0;
 54 |     }
 55 | #endif
 56 | 
 57 |     ~Stack() {
 58 |         Destroy();
 59 |     }
 60 | 
 61 | #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
 62 |     Stack& operator=(Stack&& rhs) {
 63 |         if (&rhs != this)
 64 |         {
 65 |             Destroy();
 66 | 
 67 |             allocator_ = rhs.allocator_;
 68 |             ownAllocator_ = rhs.ownAllocator_;
 69 |             stack_ = rhs.stack_;
 70 |             stackTop_ = rhs.stackTop_;
 71 |             stackEnd_ = rhs.stackEnd_;
 72 |             initialCapacity_ = rhs.initialCapacity_;
 73 | 
 74 |             rhs.allocator_ = 0;
 75 |             rhs.ownAllocator_ = 0;
 76 |             rhs.stack_ = 0;
 77 |             rhs.stackTop_ = 0;
 78 |             rhs.stackEnd_ = 0;
 79 |             rhs.initialCapacity_ = 0;
 80 |         }
 81 |         return *this;
 82 |     }
 83 | #endif
 84 | 
 85 |     void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
 86 |         internal::Swap(allocator_, rhs.allocator_);
 87 |         internal::Swap(ownAllocator_, rhs.ownAllocator_);
 88 |         internal::Swap(stack_, rhs.stack_);
 89 |         internal::Swap(stackTop_, rhs.stackTop_);
 90 |         internal::Swap(stackEnd_, rhs.stackEnd_);
 91 |         internal::Swap(initialCapacity_, rhs.initialCapacity_);
 92 |     }
 93 | 
 94 |     void Clear() { stackTop_ = stack_; }
 95 | 
 96 |     void ShrinkToFit() { 
 97 |         if (Empty()) {
 98 |             // If the stack is empty, completely deallocate the memory.
 99 |             Allocator::Free(stack_);
100 |             stack_ = 0;
101 |             stackTop_ = 0;
102 |             stackEnd_ = 0;
103 |         }
104 |         else
105 |             Resize(GetSize());
106 |     }
107 | 
108 |     // Optimization note: try to minimize the size of this function for force inline.
109 |     // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
110 |     template
111 |     RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
112 |          // Expand the stack if needed
113 |         if (stackTop_ + sizeof(T) * count >= stackEnd_)
114 |             Expand(count);
115 | 
116 |         T* ret = reinterpret_cast(stackTop_);
117 |         stackTop_ += sizeof(T) * count;
118 |         return ret;
119 |     }
120 | 
121 |     template
122 |     T* Pop(size_t count) {
123 |         RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
124 |         stackTop_ -= count * sizeof(T);
125 |         return reinterpret_cast(stackTop_);
126 |     }
127 | 
128 |     template
129 |     T* Top() { 
130 |         RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
131 |         return reinterpret_cast(stackTop_ - sizeof(T));
132 |     }
133 | 
134 |     template
135 |     T* Bottom() { return (T*)stack_; }
136 | 
137 |     Allocator& GetAllocator() { return *allocator_; }
138 |     bool Empty() const { return stackTop_ == stack_; }
139 |     size_t GetSize() const { return static_cast(stackTop_ - stack_); }
140 |     size_t GetCapacity() const { return static_cast(stackEnd_ - stack_); }
141 | 
142 | private:
143 |     template
144 |     void Expand(size_t count) {
145 |         // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
146 |         size_t newCapacity;
147 |         if (stack_ == 0) {
148 |             if (!allocator_)
149 |                 ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
150 |             newCapacity = initialCapacity_;
151 |         } else {
152 |             newCapacity = GetCapacity();
153 |             newCapacity += (newCapacity + 1) / 2;
154 |         }
155 |         size_t newSize = GetSize() + sizeof(T) * count;
156 |         if (newCapacity < newSize)
157 |             newCapacity = newSize;
158 | 
159 |         Resize(newCapacity);
160 |     }
161 | 
162 |     void Resize(size_t newCapacity) {
163 |         const size_t size = GetSize();  // Backup the current size
164 |         stack_ = (char*)allocator_->Realloc(stack_, GetCapacity(), newCapacity);
165 |         stackTop_ = stack_ + size;
166 |         stackEnd_ = stack_ + newCapacity;
167 |     }
168 | 
169 |     void Destroy() {
170 |         Allocator::Free(stack_);
171 |         RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
172 |     }
173 | 
174 |     // Prohibit copy constructor & assignment operator.
175 |     Stack(const Stack&);
176 |     Stack& operator=(const Stack&);
177 | 
178 |     Allocator* allocator_;
179 |     Allocator* ownAllocator_;
180 |     char *stack_;
181 |     char *stackTop_;
182 |     char *stackEnd_;
183 |     size_t initialCapacity_;
184 | };
185 | 
186 | } // namespace internal
187 | RAPIDJSON_NAMESPACE_END
188 | 
189 | #endif // RAPIDJSON_STACK_H_
190 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/meta.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef RAPIDJSON_INTERNAL_META_H_
 16 | #define RAPIDJSON_INTERNAL_META_H_
 17 | 
 18 | #include "../rapidjson.h"
 19 | 
 20 | #ifdef __GNUC__
 21 | RAPIDJSON_DIAG_PUSH
 22 | RAPIDJSON_DIAG_OFF(effc++)
 23 | #endif
 24 | #if defined(_MSC_VER)
 25 | RAPIDJSON_DIAG_PUSH
 26 | RAPIDJSON_DIAG_OFF(6334)
 27 | #endif
 28 | 
 29 | #if RAPIDJSON_HAS_CXX11_TYPETRAITS
 30 | #include 
 31 | #endif
 32 | 
 33 | //@cond RAPIDJSON_INTERNAL
 34 | RAPIDJSON_NAMESPACE_BEGIN
 35 | namespace internal {
 36 | 
 37 | // Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
 38 | template  struct Void { typedef void Type; };
 39 | 
 40 | ///////////////////////////////////////////////////////////////////////////////
 41 | // BoolType, TrueType, FalseType
 42 | //
 43 | template  struct BoolType {
 44 |     static const bool Value = Cond;
 45 |     typedef BoolType Type;
 46 | };
 47 | typedef BoolType TrueType;
 48 | typedef BoolType FalseType;
 49 | 
 50 | 
 51 | ///////////////////////////////////////////////////////////////////////////////
 52 | // SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
 53 | //
 54 | 
 55 | template  struct SelectIfImpl { template  struct Apply { typedef T1 Type; }; };
 56 | template <> struct SelectIfImpl { template  struct Apply { typedef T2 Type; }; };
 57 | template  struct SelectIfCond : SelectIfImpl::template Apply {};
 58 | template  struct SelectIf : SelectIfCond {};
 59 | 
 60 | template  struct AndExprCond : FalseType {};
 61 | template <> struct AndExprCond : TrueType {};
 62 | template  struct OrExprCond : TrueType {};
 63 | template <> struct OrExprCond : FalseType {};
 64 | 
 65 | template  struct BoolExpr : SelectIf::Type {};
 66 | template  struct NotExpr  : SelectIf::Type {};
 67 | template  struct AndExpr : AndExprCond::Type {};
 68 | template  struct OrExpr  : OrExprCond::Type {};
 69 | 
 70 | 
 71 | ///////////////////////////////////////////////////////////////////////////////
 72 | // AddConst, MaybeAddConst, RemoveConst
 73 | template  struct AddConst { typedef const T Type; };
 74 | template  struct MaybeAddConst : SelectIfCond {};
 75 | template  struct RemoveConst { typedef T Type; };
 76 | template  struct RemoveConst { typedef T Type; };
 77 | 
 78 | 
 79 | ///////////////////////////////////////////////////////////////////////////////
 80 | // IsSame, IsConst, IsMoreConst, IsPointer
 81 | //
 82 | template  struct IsSame : FalseType {};
 83 | template  struct IsSame : TrueType {};
 84 | 
 85 | template  struct IsConst : FalseType {};
 86 | template  struct IsConst : TrueType {};
 87 | 
 88 | template 
 89 | struct IsMoreConst
 90 |     : AndExpr::Type, typename RemoveConst::Type>,
 91 |               BoolType::Value >= IsConst::Value> >::Type {};
 92 | 
 93 | template  struct IsPointer : FalseType {};
 94 | template  struct IsPointer : TrueType {};
 95 | 
 96 | ///////////////////////////////////////////////////////////////////////////////
 97 | // IsBaseOf
 98 | //
 99 | #if RAPIDJSON_HAS_CXX11_TYPETRAITS
100 | 
101 | template  struct IsBaseOf
102 |     : BoolType< ::std::is_base_of::value> {};
103 | 
104 | #else // simplified version adopted from Boost
105 | 
106 | template struct IsBaseOfImpl {
107 |     RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
108 |     RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
109 | 
110 |     typedef char (&Yes)[1];
111 |     typedef char (&No) [2];
112 | 
113 |     template 
114 |     static Yes Check(const D*, T);
115 |     static No  Check(const B*, int);
116 | 
117 |     struct Host {
118 |         operator const B*() const;
119 |         operator const D*();
120 |     };
121 | 
122 |     enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
123 | };
124 | 
125 | template  struct IsBaseOf
126 |     : OrExpr, BoolExpr > >::Type {};
127 | 
128 | #endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
129 | 
130 | 
131 | //////////////////////////////////////////////////////////////////////////
132 | // EnableIf / DisableIf
133 | //
134 | template  struct EnableIfCond  { typedef T Type; };
135 | template  struct EnableIfCond { /* empty */ };
136 | 
137 | template  struct DisableIfCond { typedef T Type; };
138 | template  struct DisableIfCond { /* empty */ };
139 | 
140 | template 
141 | struct EnableIf : EnableIfCond {};
142 | 
143 | template 
144 | struct DisableIf : DisableIfCond {};
145 | 
146 | // SFINAE helpers
147 | struct SfinaeTag {};
148 | template  struct RemoveSfinaeTag;
149 | template  struct RemoveSfinaeTag { typedef T Type; };
150 | 
151 | #define RAPIDJSON_REMOVEFPTR_(type) \
152 |     typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
153 |         < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
154 | 
155 | #define RAPIDJSON_ENABLEIF(cond) \
156 |     typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
157 |         ::Type * = NULL
158 | 
159 | #define RAPIDJSON_DISABLEIF(cond) \
160 |     typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
161 |         ::Type * = NULL
162 | 
163 | #define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
164 |     typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
165 |         ::Type
167 | 
168 | #define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
169 |     typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
170 |         ::Type
172 | 
173 | } // namespace internal
174 | RAPIDJSON_NAMESPACE_END
175 | //@endcond
176 | 
177 | #if defined(__GNUC__) || defined(_MSC_VER)
178 | RAPIDJSON_DIAG_POP
179 | #endif
180 | 
181 | #endif // RAPIDJSON_INTERNAL_META_H_
182 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/dtoa.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | // This is a C++ header-only implementation of Grisu2 algorithm from the publication:
 16 | // Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
 17 | // integers." ACM Sigplan Notices 45.6 (2010): 233-243.
 18 | 
 19 | #ifndef RAPIDJSON_DTOA_
 20 | #define RAPIDJSON_DTOA_
 21 | 
 22 | #include "itoa.h" // GetDigitsLut()
 23 | #include "diyfp.h"
 24 | #include "ieee754.h"
 25 | 
 26 | RAPIDJSON_NAMESPACE_BEGIN
 27 | namespace internal {
 28 | 
 29 | #ifdef __GNUC__
 30 | RAPIDJSON_DIAG_PUSH
 31 | RAPIDJSON_DIAG_OFF(effc++)
 32 | #endif
 33 | 
 34 | inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
 35 |     while (rest < wp_w && delta - rest >= ten_kappa &&
 36 |            (rest + ten_kappa < wp_w ||  /// closer
 37 |             wp_w - rest > rest + ten_kappa - wp_w)) {
 38 |         buffer[len - 1]--;
 39 |         rest += ten_kappa;
 40 |     }
 41 | }
 42 | 
 43 | inline unsigned CountDecimalDigit32(uint32_t n) {
 44 |     // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
 45 |     if (n < 10) return 1;
 46 |     if (n < 100) return 2;
 47 |     if (n < 1000) return 3;
 48 |     if (n < 10000) return 4;
 49 |     if (n < 100000) return 5;
 50 |     if (n < 1000000) return 6;
 51 |     if (n < 10000000) return 7;
 52 |     if (n < 100000000) return 8;
 53 |     // Will not reach 10 digits in DigitGen()
 54 |     //if (n < 1000000000) return 9;
 55 |     //return 10;
 56 |     return 9;
 57 | }
 58 | 
 59 | inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
 60 |     static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
 61 |     const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
 62 |     const DiyFp wp_w = Mp - W;
 63 |     uint32_t p1 = static_cast(Mp.f >> -one.e);
 64 |     uint64_t p2 = Mp.f & (one.f - 1);
 65 |     unsigned kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
 66 |     *len = 0;
 67 | 
 68 |     while (kappa > 0) {
 69 |         uint32_t d = 0;
 70 |         switch (kappa) {
 71 |             case  9: d = p1 /  100000000; p1 %=  100000000; break;
 72 |             case  8: d = p1 /   10000000; p1 %=   10000000; break;
 73 |             case  7: d = p1 /    1000000; p1 %=    1000000; break;
 74 |             case  6: d = p1 /     100000; p1 %=     100000; break;
 75 |             case  5: d = p1 /      10000; p1 %=      10000; break;
 76 |             case  4: d = p1 /       1000; p1 %=       1000; break;
 77 |             case  3: d = p1 /        100; p1 %=        100; break;
 78 |             case  2: d = p1 /         10; p1 %=         10; break;
 79 |             case  1: d = p1;              p1 =           0; break;
 80 |             default:;
 81 |         }
 82 |         if (d || *len)
 83 |             buffer[(*len)++] = static_cast('0' + static_cast(d));
 84 |         kappa--;
 85 |         uint64_t tmp = (static_cast(p1) << -one.e) + p2;
 86 |         if (tmp <= delta) {
 87 |             *K += kappa;
 88 |             GrisuRound(buffer, *len, delta, tmp, static_cast(kPow10[kappa]) << -one.e, wp_w.f);
 89 |             return;
 90 |         }
 91 |     }
 92 | 
 93 |     // kappa = 0
 94 |     for (;;) {
 95 |         p2 *= 10;
 96 |         delta *= 10;
 97 |         char d = static_cast(p2 >> -one.e);
 98 |         if (d || *len)
 99 |             buffer[(*len)++] = static_cast('0' + d);
100 |         p2 &= one.f - 1;
101 |         kappa--;
102 |         if (p2 < delta) {
103 |             *K += kappa;
104 |             GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-static_cast(kappa)]);
105 |             return;
106 |         }
107 |     }
108 | }
109 | 
110 | inline void Grisu2(double value, char* buffer, int* length, int* K) {
111 |     const DiyFp v(value);
112 |     DiyFp w_m, w_p;
113 |     v.NormalizedBoundaries(&w_m, &w_p);
114 | 
115 |     const DiyFp c_mk = GetCachedPower(w_p.e, K);
116 |     const DiyFp W = v.Normalize() * c_mk;
117 |     DiyFp Wp = w_p * c_mk;
118 |     DiyFp Wm = w_m * c_mk;
119 |     Wm.f++;
120 |     Wp.f--;
121 |     DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
122 | }
123 | 
124 | inline char* WriteExponent(int K, char* buffer) {
125 |     if (K < 0) {
126 |         *buffer++ = '-';
127 |         K = -K;
128 |     }
129 | 
130 |     if (K >= 100) {
131 |         *buffer++ = static_cast('0' + static_cast(K / 100));
132 |         K %= 100;
133 |         const char* d = GetDigitsLut() + K * 2;
134 |         *buffer++ = d[0];
135 |         *buffer++ = d[1];
136 |     }
137 |     else if (K >= 10) {
138 |         const char* d = GetDigitsLut() + K * 2;
139 |         *buffer++ = d[0];
140 |         *buffer++ = d[1];
141 |     }
142 |     else
143 |         *buffer++ = static_cast('0' + static_cast(K));
144 | 
145 |     return buffer;
146 | }
147 | 
148 | inline char* Prettify(char* buffer, int length, int k) {
149 |     const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
150 | 
151 |     if (length <= kk && kk <= 21) {
152 |         // 1234e7 -> 12340000000
153 |         for (int i = length; i < kk; i++)
154 |             buffer[i] = '0';
155 |         buffer[kk] = '.';
156 |         buffer[kk + 1] = '0';
157 |         return &buffer[kk + 2];
158 |     }
159 |     else if (0 < kk && kk <= 21) {
160 |         // 1234e-2 -> 12.34
161 |         std::memmove(&buffer[kk + 1], &buffer[kk], static_cast(length - kk));
162 |         buffer[kk] = '.';
163 |         return &buffer[length + 1];
164 |     }
165 |     else if (-6 < kk && kk <= 0) {
166 |         // 1234e-6 -> 0.001234
167 |         const int offset = 2 - kk;
168 |         std::memmove(&buffer[offset], &buffer[0], static_cast(length));
169 |         buffer[0] = '0';
170 |         buffer[1] = '.';
171 |         for (int i = 2; i < offset; i++)
172 |             buffer[i] = '0';
173 |         return &buffer[length + offset];
174 |     }
175 |     else if (length == 1) {
176 |         // 1e30
177 |         buffer[1] = 'e';
178 |         return WriteExponent(kk - 1, &buffer[2]);
179 |     }
180 |     else {
181 |         // 1234e30 -> 1.234e33
182 |         std::memmove(&buffer[2], &buffer[1], static_cast(length - 1));
183 |         buffer[1] = '.';
184 |         buffer[length + 1] = 'e';
185 |         return WriteExponent(kk - 1, &buffer[0 + length + 2]);
186 |     }
187 | }
188 | 
189 | inline char* dtoa(double value, char* buffer) {
190 |     Double d(value);
191 |     if (d.IsZero()) {
192 |         if (d.Sign())
193 |             *buffer++ = '-';     // -0.0, Issue #289
194 |         buffer[0] = '0';
195 |         buffer[1] = '.';
196 |         buffer[2] = '0';
197 |         return &buffer[3];
198 |     }
199 |     else {
200 |         if (value < 0) {
201 |             *buffer++ = '-';
202 |             value = -value;
203 |         }
204 |         int length, K;
205 |         Grisu2(value, buffer, &length, &K);
206 |         return Prettify(buffer, length, K);
207 |     }
208 | }
209 | 
210 | #ifdef __GNUC__
211 | RAPIDJSON_DIAG_POP
212 | #endif
213 | 
214 | } // namespace internal
215 | RAPIDJSON_NAMESPACE_END
216 | 
217 | #endif // RAPIDJSON_DTOA_
218 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/prettywriter.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef RAPIDJSON_PRETTYWRITER_H_
 16 | #define RAPIDJSON_PRETTYWRITER_H_
 17 | 
 18 | #include "writer.h"
 19 | 
 20 | #ifdef __GNUC__
 21 | RAPIDJSON_DIAG_PUSH
 22 | RAPIDJSON_DIAG_OFF(effc++)
 23 | #endif
 24 | 
 25 | RAPIDJSON_NAMESPACE_BEGIN
 26 | 
 27 | //! Writer with indentation and spacing.
 28 | /*!
 29 |     \tparam OutputStream Type of ouptut os.
 30 |     \tparam SourceEncoding Encoding of source string.
 31 |     \tparam TargetEncoding Encoding of output stream.
 32 |     \tparam StackAllocator Type of allocator for allocating memory of stack.
 33 | */
 34 | template, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator>
 35 | class PrettyWriter : public Writer {
 36 | public:
 37 |     typedef Writer Base;
 38 |     typedef typename Base::Ch Ch;
 39 | 
 40 |     //! Constructor
 41 |     /*! \param os Output stream.
 42 |         \param allocator User supplied allocator. If it is null, it will create a private one.
 43 |         \param levelDepth Initial capacity of stack.
 44 |     */
 45 |     PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
 46 |         Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
 47 | 
 48 |     //! Set custom indentation.
 49 |     /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
 50 |         \param indentCharCount  Number of indent characters for each indentation level.
 51 |         \note The default indentation is 4 spaces.
 52 |     */
 53 |     PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
 54 |         RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
 55 |         indentChar_ = indentChar;
 56 |         indentCharCount_ = indentCharCount;
 57 |         return *this;
 58 |     }
 59 | 
 60 |     /*! @name Implementation of Handler
 61 |         \see Handler
 62 |     */
 63 |     //@{
 64 | 
 65 |     bool Null()                 { PrettyPrefix(kNullType);   return Base::WriteNull(); }
 66 |     bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
 67 |     bool Int(int i)             { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
 68 |     bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
 69 |     bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
 70 |     bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::WriteUint64(u64);  }
 71 |     bool Double(double d)       { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
 72 | 
 73 |     bool String(const Ch* str, SizeType length, bool copy = false) {
 74 |         (void)copy;
 75 |         PrettyPrefix(kStringType);
 76 |         return Base::WriteString(str, length);
 77 |     }
 78 | 
 79 | #if RAPIDJSON_HAS_STDSTRING
 80 |     bool String(const std::basic_string& str) {
 81 |         return String(str.data(), SizeType(str.size()));
 82 |     }
 83 | #endif
 84 | 
 85 |     bool StartObject() {
 86 |         PrettyPrefix(kObjectType);
 87 |         new (Base::level_stack_.template Push()) typename Base::Level(false);
 88 |         return Base::WriteStartObject();
 89 |     }
 90 | 
 91 |     bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
 92 | 	
 93 |     bool EndObject(SizeType memberCount = 0) {
 94 |         (void)memberCount;
 95 |         RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
 96 |         RAPIDJSON_ASSERT(!Base::level_stack_.template Top()->inArray);
 97 |         bool empty = Base::level_stack_.template Pop(1)->valueCount == 0;
 98 | 
 99 |         if (!empty) {
100 |             Base::os_->Put('\n');
101 |             WriteIndent();
102 |         }
103 |         bool ret = Base::WriteEndObject();
104 |         (void)ret;
105 |         RAPIDJSON_ASSERT(ret == true);
106 |         if (Base::level_stack_.Empty()) // end of json text
107 |             Base::os_->Flush();
108 |         return true;
109 |     }
110 | 
111 |     bool StartArray() {
112 |         PrettyPrefix(kArrayType);
113 |         new (Base::level_stack_.template Push()) typename Base::Level(true);
114 |         return Base::WriteStartArray();
115 |     }
116 | 
117 |     bool EndArray(SizeType memberCount = 0) {
118 |         (void)memberCount;
119 |         RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
120 |         RAPIDJSON_ASSERT(Base::level_stack_.template Top()->inArray);
121 |         bool empty = Base::level_stack_.template Pop(1)->valueCount == 0;
122 | 
123 |         if (!empty) {
124 |             Base::os_->Put('\n');
125 |             WriteIndent();
126 |         }
127 |         bool ret = Base::WriteEndArray();
128 |         (void)ret;
129 |         RAPIDJSON_ASSERT(ret == true);
130 |         if (Base::level_stack_.Empty()) // end of json text
131 |             Base::os_->Flush();
132 |         return true;
133 |     }
134 | 
135 |     //@}
136 | 
137 |     /*! @name Convenience extensions */
138 |     //@{
139 | 
140 |     //! Simpler but slower overload.
141 |     bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
142 |     bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
143 | 
144 |     //@}
145 | protected:
146 |     void PrettyPrefix(Type type) {
147 |         (void)type;
148 |         if (Base::level_stack_.GetSize() != 0) { // this value is not at root
149 |             typename Base::Level* level = Base::level_stack_.template Top();
150 | 
151 |             if (level->inArray) {
152 |                 if (level->valueCount > 0) {
153 |                     Base::os_->Put(','); // add comma if it is not the first element in array
154 |                     Base::os_->Put('\n');
155 |                 }
156 |                 else
157 |                     Base::os_->Put('\n');
158 |                 WriteIndent();
159 |             }
160 |             else {  // in object
161 |                 if (level->valueCount > 0) {
162 |                     if (level->valueCount % 2 == 0) {
163 |                         Base::os_->Put(',');
164 |                         Base::os_->Put('\n');
165 |                     }
166 |                     else {
167 |                         Base::os_->Put(':');
168 |                         Base::os_->Put(' ');
169 |                     }
170 |                 }
171 |                 else
172 |                     Base::os_->Put('\n');
173 | 
174 |                 if (level->valueCount % 2 == 0)
175 |                     WriteIndent();
176 |             }
177 |             if (!level->inArray && level->valueCount % 2 == 0)
178 |                 RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
179 |             level->valueCount++;
180 |         }
181 |         else {
182 |             RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
183 |             Base::hasRoot_ = true;
184 |         }
185 |     }
186 | 
187 |     void WriteIndent()  {
188 |         size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
189 |         PutN(*Base::os_, indentChar_, count);
190 |     }
191 | 
192 |     Ch indentChar_;
193 |     unsigned indentCharCount_;
194 | 
195 | private:
196 |     // Prohibit copy constructor & assignment operator.
197 |     PrettyWriter(const PrettyWriter&);
198 |     PrettyWriter& operator=(const PrettyWriter&);
199 | };
200 | 
201 | RAPIDJSON_NAMESPACE_END
202 | 
203 | #ifdef __GNUC__
204 | RAPIDJSON_DIAG_POP
205 | #endif
206 | 
207 | #endif // RAPIDJSON_RAPIDJSON_H_
208 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/internal/strtod.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef RAPIDJSON_STRTOD_
 16 | #define RAPIDJSON_STRTOD_
 17 | 
 18 | #include "../rapidjson.h"
 19 | #include "ieee754.h"
 20 | #include "biginteger.h"
 21 | #include "diyfp.h"
 22 | #include "pow10.h"
 23 | 
 24 | RAPIDJSON_NAMESPACE_BEGIN
 25 | namespace internal {
 26 | 
 27 | inline double FastPath(double significand, int exp) {
 28 |     if (exp < -308)
 29 |         return 0.0;
 30 |     else if (exp >= 0)
 31 |         return significand * internal::Pow10(exp);
 32 |     else
 33 |         return significand / internal::Pow10(-exp);
 34 | }
 35 | 
 36 | inline double StrtodNormalPrecision(double d, int p) {
 37 |     if (p < -308) {
 38 |         // Prevent expSum < -308, making Pow10(p) = 0
 39 |         d = FastPath(d, -308);
 40 |         d = FastPath(d, p + 308);
 41 |     }
 42 |     else
 43 |         d = FastPath(d, p);
 44 |     return d;
 45 | }
 46 | 
 47 | template 
 48 | inline T Min3(T a, T b, T c) {
 49 |     T m = a;
 50 |     if (m > b) m = b;
 51 |     if (m > c) m = c;
 52 |     return m;
 53 | }
 54 | 
 55 | inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
 56 |     const Double db(b);
 57 |     const uint64_t bInt = db.IntegerSignificand();
 58 |     const int bExp = db.IntegerExponent();
 59 |     const int hExp = bExp - 1;
 60 | 
 61 |     int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
 62 | 
 63 |     // Adjust for decimal exponent
 64 |     if (dExp >= 0) {
 65 |         dS_Exp2 += dExp;
 66 |         dS_Exp5 += dExp;
 67 |     }
 68 |     else {
 69 |         bS_Exp2 -= dExp;
 70 |         bS_Exp5 -= dExp;
 71 |         hS_Exp2 -= dExp;
 72 |         hS_Exp5 -= dExp;
 73 |     }
 74 | 
 75 |     // Adjust for binary exponent
 76 |     if (bExp >= 0)
 77 |         bS_Exp2 += bExp;
 78 |     else {
 79 |         dS_Exp2 -= bExp;
 80 |         hS_Exp2 -= bExp;
 81 |     }
 82 | 
 83 |     // Adjust for half ulp exponent
 84 |     if (hExp >= 0)
 85 |         hS_Exp2 += hExp;
 86 |     else {
 87 |         dS_Exp2 -= hExp;
 88 |         bS_Exp2 -= hExp;
 89 |     }
 90 | 
 91 |     // Remove common power of two factor from all three scaled values
 92 |     int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
 93 |     dS_Exp2 -= common_Exp2;
 94 |     bS_Exp2 -= common_Exp2;
 95 |     hS_Exp2 -= common_Exp2;
 96 | 
 97 |     BigInteger dS = d;
 98 |     dS.MultiplyPow5(static_cast(dS_Exp5)) <<= static_cast(dS_Exp2);
 99 | 
100 |     BigInteger bS(bInt);
101 |     bS.MultiplyPow5(static_cast(bS_Exp5)) <<= static_cast(bS_Exp2);
102 | 
103 |     BigInteger hS(1);
104 |     hS.MultiplyPow5(static_cast(hS_Exp5)) <<= static_cast(hS_Exp2);
105 | 
106 |     BigInteger delta(0);
107 |     dS.Difference(bS, &delta);
108 | 
109 |     return delta.Compare(hS);
110 | }
111 | 
112 | inline bool StrtodFast(double d, int p, double* result) {
113 |     // Use fast path for string-to-double conversion if possible
114 |     // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
115 |     if (p > 22  && p < 22 + 16) {
116 |         // Fast Path Cases In Disguise
117 |         d *= internal::Pow10(p - 22);
118 |         p = 22;
119 |     }
120 | 
121 |     if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
122 |         *result = FastPath(d, p);
123 |         return true;
124 |     }
125 |     else
126 |         return false;
127 | }
128 | 
129 | // Compute an approximation and see if it is within 1/2 ULP
130 | inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
131 |     uint64_t significand = 0;
132 |     size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
133 |     for (; i < length; i++) {
134 |         if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
135 |             (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
136 |             break;
137 |         significand = significand * 10u + static_cast(decimals[i] - '0');
138 |     }
139 |     
140 |     if (i < length && decimals[i] >= '5') // Rounding
141 |         significand++;
142 | 
143 |     size_t remaining = length - i;
144 |     const unsigned kUlpShift = 3;
145 |     const unsigned kUlp = 1 << kUlpShift;
146 |     int error = (remaining == 0) ? 0 : kUlp / 2;
147 | 
148 |     DiyFp v(significand, 0);
149 |     v = v.Normalize();
150 |     error <<= -v.e;
151 | 
152 |     const int dExp = (int)decimalPosition - (int)i + exp;
153 | 
154 |     int actualExp;
155 |     DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
156 |     if (actualExp != dExp) {
157 |         static const DiyFp kPow10[] = {
158 |             DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
159 |             DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
160 |             DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
161 |             DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
162 |             DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
163 |             DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
164 |             DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
165 |         };
166 |         int  adjustment = dExp - actualExp - 1;
167 |         RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
168 |         v = v * kPow10[adjustment];
169 |         if (length + static_cast(adjustment)> 19u) // has more digits than decimal digits in 64-bit
170 |             error += kUlp / 2;
171 |     }
172 | 
173 |     v = v * cachedPower;
174 | 
175 |     error += kUlp + (error == 0 ? 0 : 1);
176 | 
177 |     const int oldExp = v.e;
178 |     v = v.Normalize();
179 |     error <<= oldExp - v.e;
180 | 
181 |     const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
182 |     unsigned precisionSize = 64 - effectiveSignificandSize;
183 |     if (precisionSize + kUlpShift >= 64) {
184 |         unsigned scaleExp = (precisionSize + kUlpShift) - 63;
185 |         v.f >>= scaleExp;
186 |         v.e += scaleExp; 
187 |         error = (error >> scaleExp) + 1 + static_cast(kUlp);
188 |         precisionSize -= scaleExp;
189 |     }
190 | 
191 |     DiyFp rounded(v.f >> precisionSize, v.e + static_cast(precisionSize));
192 |     const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
193 |     const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
194 |     if (precisionBits >= halfWay + static_cast(error)) {
195 |         rounded.f++;
196 |         if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
197 |             rounded.f >>= 1;
198 |             rounded.e++;
199 |         }
200 |     }
201 | 
202 |     *result = rounded.ToDouble();
203 | 
204 |     return halfWay - static_cast(error) >= precisionBits || precisionBits >= halfWay + static_cast(error);
205 | }
206 | 
207 | inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
208 |     const BigInteger dInt(decimals, length);
209 |     const int dExp = (int)decimalPosition - (int)length + exp;
210 |     Double a(approx);
211 |     int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
212 |     if (cmp < 0)
213 |         return a.Value();  // within half ULP
214 |     else if (cmp == 0) {
215 |         // Round towards even
216 |         if (a.Significand() & 1)
217 |             return a.NextPositiveDouble();
218 |         else
219 |             return a.Value();
220 |     }
221 |     else // adjustment
222 |         return a.NextPositiveDouble();
223 | }
224 | 
225 | inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
226 |     RAPIDJSON_ASSERT(d >= 0.0);
227 |     RAPIDJSON_ASSERT(length >= 1);
228 | 
229 |     double result;
230 |     if (StrtodFast(d, p, &result))
231 |         return result;
232 | 
233 |     // Trim leading zeros
234 |     while (*decimals == '0' && length > 1) {
235 |         length--;
236 |         decimals++;
237 |         decimalPosition--;
238 |     }
239 | 
240 |     // Trim trailing zeros
241 |     while (decimals[length - 1] == '0' && length > 1) {
242 |         length--;
243 |         decimalPosition--;
244 |         exp++;
245 |     }
246 | 
247 |     // Trim right-most digits
248 |     const int kMaxDecimalDigit = 780;
249 |     if ((int)length > kMaxDecimalDigit) {
250 |         int delta = (int(length) - kMaxDecimalDigit);
251 |         exp += delta;
252 |         decimalPosition -= static_cast(delta);
253 |         length = kMaxDecimalDigit;
254 |     }
255 | 
256 |     // If too small, underflow to zero
257 |     if (int(length) + exp < -324)
258 |         return 0.0;
259 | 
260 |     if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
261 |         return result;
262 | 
263 |     // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
264 |     return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
265 | }
266 | 
267 | } // namespace internal
268 | RAPIDJSON_NAMESPACE_END
269 | 
270 | #endif // RAPIDJSON_STRTOD_
271 | 


--------------------------------------------------------------------------------
/ImageProc/include/rapidjson/msinttypes/inttypes.h:
--------------------------------------------------------------------------------
  1 | // ISO C9x  compliant inttypes.h for Microsoft Visual Studio
  2 | // Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
  3 | // 
  4 | //  Copyright (c) 2006-2013 Alexander Chemeris
  5 | // 
  6 | // Redistribution and use in source and binary forms, with or without
  7 | // modification, are permitted provided that the following conditions are met:
  8 | // 
  9 | //   1. Redistributions of source code must retain the above copyright notice,
 10 | //      this list of conditions and the following disclaimer.
 11 | // 
 12 | //   2. Redistributions in binary form must reproduce the above copyright
 13 | //      notice, this list of conditions and the following disclaimer in the
 14 | //      documentation and/or other materials provided with the distribution.
 15 | // 
 16 | //   3. Neither the name of the product nor the names of its contributors may
 17 | //      be used to endorse or promote products derived from this software
 18 | //      without specific prior written permission.
 19 | // 
 20 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 21 | // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 22 | // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 23 | // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 25 | // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 26 | // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 27 | // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 28 | // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 29 | // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30 | // 
 31 | ///////////////////////////////////////////////////////////////////////////////
 32 | 
 33 | // The above software in this distribution may have been modified by 
 34 | // THL A29 Limited ("Tencent Modifications"). 
 35 | // All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
 36 | 
 37 | #ifndef _MSC_VER // [
 38 | #error "Use this header only with Microsoft Visual C++ compilers!"
 39 | #endif // _MSC_VER ]
 40 | 
 41 | #ifndef _MSC_INTTYPES_H_ // [
 42 | #define _MSC_INTTYPES_H_
 43 | 
 44 | #if _MSC_VER > 1000
 45 | #pragma once
 46 | #endif
 47 | 
 48 | #include "stdint.h"
 49 | 
 50 | // miloyip: VC supports inttypes.h since VC2013
 51 | #if _MSC_VER >= 1800
 52 | #include 
 53 | #else
 54 | 
 55 | // 7.8 Format conversion of integer types
 56 | 
 57 | typedef struct {
 58 |    intmax_t quot;
 59 |    intmax_t rem;
 60 | } imaxdiv_t;
 61 | 
 62 | // 7.8.1 Macros for format specifiers
 63 | 
 64 | #if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
 65 | 
 66 | // The fprintf macros for signed integers are:
 67 | #define PRId8       "d"
 68 | #define PRIi8       "i"
 69 | #define PRIdLEAST8  "d"
 70 | #define PRIiLEAST8  "i"
 71 | #define PRIdFAST8   "d"
 72 | #define PRIiFAST8   "i"
 73 | 
 74 | #define PRId16       "hd"
 75 | #define PRIi16       "hi"
 76 | #define PRIdLEAST16  "hd"
 77 | #define PRIiLEAST16  "hi"
 78 | #define PRIdFAST16   "hd"
 79 | #define PRIiFAST16   "hi"
 80 | 
 81 | #define PRId32       "I32d"
 82 | #define PRIi32       "I32i"
 83 | #define PRIdLEAST32  "I32d"
 84 | #define PRIiLEAST32  "I32i"
 85 | #define PRIdFAST32   "I32d"
 86 | #define PRIiFAST32   "I32i"
 87 | 
 88 | #define PRId64       "I64d"
 89 | #define PRIi64       "I64i"
 90 | #define PRIdLEAST64  "I64d"
 91 | #define PRIiLEAST64  "I64i"
 92 | #define PRIdFAST64   "I64d"
 93 | #define PRIiFAST64   "I64i"
 94 | 
 95 | #define PRIdMAX     "I64d"
 96 | #define PRIiMAX     "I64i"
 97 | 
 98 | #define PRIdPTR     "Id"
 99 | #define PRIiPTR     "Ii"
100 | 
101 | // The fprintf macros for unsigned integers are:
102 | #define PRIo8       "o"
103 | #define PRIu8       "u"
104 | #define PRIx8       "x"
105 | #define PRIX8       "X"
106 | #define PRIoLEAST8  "o"
107 | #define PRIuLEAST8  "u"
108 | #define PRIxLEAST8  "x"
109 | #define PRIXLEAST8  "X"
110 | #define PRIoFAST8   "o"
111 | #define PRIuFAST8   "u"
112 | #define PRIxFAST8   "x"
113 | #define PRIXFAST8   "X"
114 | 
115 | #define PRIo16       "ho"
116 | #define PRIu16       "hu"
117 | #define PRIx16       "hx"
118 | #define PRIX16       "hX"
119 | #define PRIoLEAST16  "ho"
120 | #define PRIuLEAST16  "hu"
121 | #define PRIxLEAST16  "hx"
122 | #define PRIXLEAST16  "hX"
123 | #define PRIoFAST16   "ho"
124 | #define PRIuFAST16   "hu"
125 | #define PRIxFAST16   "hx"
126 | #define PRIXFAST16   "hX"
127 | 
128 | #define PRIo32       "I32o"
129 | #define PRIu32       "I32u"
130 | #define PRIx32       "I32x"
131 | #define PRIX32       "I32X"
132 | #define PRIoLEAST32  "I32o"
133 | #define PRIuLEAST32  "I32u"
134 | #define PRIxLEAST32  "I32x"
135 | #define PRIXLEAST32  "I32X"
136 | #define PRIoFAST32   "I32o"
137 | #define PRIuFAST32   "I32u"
138 | #define PRIxFAST32   "I32x"
139 | #define PRIXFAST32   "I32X"
140 | 
141 | #define PRIo64       "I64o"
142 | #define PRIu64       "I64u"
143 | #define PRIx64       "I64x"
144 | #define PRIX64       "I64X"
145 | #define PRIoLEAST64  "I64o"
146 | #define PRIuLEAST64  "I64u"
147 | #define PRIxLEAST64  "I64x"
148 | #define PRIXLEAST64  "I64X"
149 | #define PRIoFAST64   "I64o"
150 | #define PRIuFAST64   "I64u"
151 | #define PRIxFAST64   "I64x"
152 | #define PRIXFAST64   "I64X"
153 | 
154 | #define PRIoMAX     "I64o"
155 | #define PRIuMAX     "I64u"
156 | #define PRIxMAX     "I64x"
157 | #define PRIXMAX     "I64X"
158 | 
159 | #define PRIoPTR     "Io"
160 | #define PRIuPTR     "Iu"
161 | #define PRIxPTR     "Ix"
162 | #define PRIXPTR     "IX"
163 | 
164 | // The fscanf macros for signed integers are:
165 | #define SCNd8       "d"
166 | #define SCNi8       "i"
167 | #define SCNdLEAST8  "d"
168 | #define SCNiLEAST8  "i"
169 | #define SCNdFAST8   "d"
170 | #define SCNiFAST8   "i"
171 | 
172 | #define SCNd16       "hd"
173 | #define SCNi16       "hi"
174 | #define SCNdLEAST16  "hd"
175 | #define SCNiLEAST16  "hi"
176 | #define SCNdFAST16   "hd"
177 | #define SCNiFAST16   "hi"
178 | 
179 | #define SCNd32       "ld"
180 | #define SCNi32       "li"
181 | #define SCNdLEAST32  "ld"
182 | #define SCNiLEAST32  "li"
183 | #define SCNdFAST32   "ld"
184 | #define SCNiFAST32   "li"
185 | 
186 | #define SCNd64       "I64d"
187 | #define SCNi64       "I64i"
188 | #define SCNdLEAST64  "I64d"
189 | #define SCNiLEAST64  "I64i"
190 | #define SCNdFAST64   "I64d"
191 | #define SCNiFAST64   "I64i"
192 | 
193 | #define SCNdMAX     "I64d"
194 | #define SCNiMAX     "I64i"
195 | 
196 | #ifdef _WIN64 // [
197 | #  define SCNdPTR     "I64d"
198 | #  define SCNiPTR     "I64i"
199 | #else  // _WIN64 ][
200 | #  define SCNdPTR     "ld"
201 | #  define SCNiPTR     "li"
202 | #endif  // _WIN64 ]
203 | 
204 | // The fscanf macros for unsigned integers are:
205 | #define SCNo8       "o"
206 | #define SCNu8       "u"
207 | #define SCNx8       "x"
208 | #define SCNX8       "X"
209 | #define SCNoLEAST8  "o"
210 | #define SCNuLEAST8  "u"
211 | #define SCNxLEAST8  "x"
212 | #define SCNXLEAST8  "X"
213 | #define SCNoFAST8   "o"
214 | #define SCNuFAST8   "u"
215 | #define SCNxFAST8   "x"
216 | #define SCNXFAST8   "X"
217 | 
218 | #define SCNo16       "ho"
219 | #define SCNu16       "hu"
220 | #define SCNx16       "hx"
221 | #define SCNX16       "hX"
222 | #define SCNoLEAST16  "ho"
223 | #define SCNuLEAST16  "hu"
224 | #define SCNxLEAST16  "hx"
225 | #define SCNXLEAST16  "hX"
226 | #define SCNoFAST16   "ho"
227 | #define SCNuFAST16   "hu"
228 | #define SCNxFAST16   "hx"
229 | #define SCNXFAST16   "hX"
230 | 
231 | #define SCNo32       "lo"
232 | #define SCNu32       "lu"
233 | #define SCNx32       "lx"
234 | #define SCNX32       "lX"
235 | #define SCNoLEAST32  "lo"
236 | #define SCNuLEAST32  "lu"
237 | #define SCNxLEAST32  "lx"
238 | #define SCNXLEAST32  "lX"
239 | #define SCNoFAST32   "lo"
240 | #define SCNuFAST32   "lu"
241 | #define SCNxFAST32   "lx"
242 | #define SCNXFAST32   "lX"
243 | 
244 | #define SCNo64       "I64o"
245 | #define SCNu64       "I64u"
246 | #define SCNx64       "I64x"
247 | #define SCNX64       "I64X"
248 | #define SCNoLEAST64  "I64o"
249 | #define SCNuLEAST64  "I64u"
250 | #define SCNxLEAST64  "I64x"
251 | #define SCNXLEAST64  "I64X"
252 | #define SCNoFAST64   "I64o"
253 | #define SCNuFAST64   "I64u"
254 | #define SCNxFAST64   "I64x"
255 | #define SCNXFAST64   "I64X"
256 | 
257 | #define SCNoMAX     "I64o"
258 | #define SCNuMAX     "I64u"
259 | #define SCNxMAX     "I64x"
260 | #define SCNXMAX     "I64X"
261 | 
262 | #ifdef _WIN64 // [
263 | #  define SCNoPTR     "I64o"
264 | #  define SCNuPTR     "I64u"
265 | #  define SCNxPTR     "I64x"
266 | #  define SCNXPTR     "I64X"
267 | #else  // _WIN64 ][
268 | #  define SCNoPTR     "lo"
269 | #  define SCNuPTR     "lu"
270 | #  define SCNxPTR     "lx"
271 | #  define SCNXPTR     "lX"
272 | #endif  // _WIN64 ]
273 | 
274 | #endif // __STDC_FORMAT_MACROS ]
275 | 
276 | // 7.8.2 Functions for greatest-width integer types
277 | 
278 | // 7.8.2.1 The imaxabs function
279 | #define imaxabs _abs64
280 | 
281 | // 7.8.2.2 The imaxdiv function
282 | 
283 | // This is modified version of div() function from Microsoft's div.c found
284 | // in %MSVC.NET%\crt\src\div.c
285 | #ifdef STATIC_IMAXDIV // [
286 | static
287 | #else // STATIC_IMAXDIV ][
288 | _inline
289 | #endif // STATIC_IMAXDIV ]
290 | imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
291 | {
292 |    imaxdiv_t result;
293 | 
294 |    result.quot = numer / denom;
295 |    result.rem = numer % denom;
296 | 
297 |    if (numer < 0 && result.rem > 0) {
298 |       // did division wrong; must fix up
299 |       ++result.quot;
300 |       result.rem -= denom;
301 |    }
302 | 
303 |    return result;
304 | }
305 | 
306 | // 7.8.2.3 The strtoimax and strtoumax functions
307 | #define strtoimax _strtoi64
308 | #define strtoumax _strtoui64
309 | 
310 | // 7.8.2.4 The wcstoimax and wcstoumax functions
311 | #define wcstoimax _wcstoi64
312 | #define wcstoumax _wcstoui64
313 | 
314 | #endif // _MSC_VER >= 1800
315 | 
316 | #endif // _MSC_INTTYPES_H_ ]
317 | 


--------------------------------------------------------------------------------