(5843,17729,'2014-06-11 22:51:49','2014-06-11 22:51:49','<p>In this post, we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.</p>\r\n<ul>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\n<p>We pitched the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU(from here on referred as TK1) on Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.</p>\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the below resolutions are used for benchmarks. \r\n<ul>\r\n<li>480p (720x480)</li>\r\n<li>720p and 1080p HD</li>\r\n<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis(Frames per second) in all the plots is on log scale. The higher the value along vertical axis, the better the run times are for that function on that specific device.\r\n\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe height=563 width=792 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode as they use the same algorithm with different local neighborhood operator.</p>\r\n\r\n<h4 id=\"median-filter\">Median filter</h4>\r\n<iframe height=561 width=794 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.</p>\r\n\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe height=561 width=793 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>We benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.</p>\r\n\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe height=566 width=794 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>Standard 256 bin <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\"><code>histogram</code></a></p>\r\n\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe height=560 width=792 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>We used 3.5(7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we got one frame per second processing speed.</p>\r\n\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe height=563 width=795 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.</p>\r\n\r\n<h3>Conclusion</h3>\r\n<ul>\r\n<li>\r\n    <code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.\r\n</li>\r\n<li>\r\n    <code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.\r\n</li>\r\n<li>\r\n    <code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.\r\n</li>\r\n<li>\r\n    <code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.\r\n</li>\r\n</ul>\r\nThere are plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The take away point from this post is that we can easily do image processing in real time using Jetson TK1 for upto 4k UHD resolution.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-11 22:51:49','2014-06-11 22:51:49','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5844,17729,'2014-06-11 22:53:46','2014-06-11 22:53:46','<p>In this post, we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.</p>\r\n<ul>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a><br /></li>\r\n<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\n<p>We pitched the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU(from here on referred as TK1) on Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.</p>\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the below resolutions are used for benchmarks. \r\n<ul>\r\n<li>480p (720x480)</li>\r\n<li>720p and 1080p HD</li>\r\n<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis(Frames per second) in all the plots is on log scale. The higher the value along vertical axis, the better the run times are for that function on that specific device.\r\n\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe height=563 width=792 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode as they use the same algorithm with different local neighborhood operator.</p>\r\n\r\n<h4 id=\"median-filter\">Median filter</h4>\r\n<iframe height=561 width=794 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.</p>\r\n\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe height=561 width=793 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>We benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.</p>\r\n\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe height=566 width=794 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>Standard 256 bin <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\"><code>histogram</code></a></p>\r\n\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe height=560 width=792 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>We used 3.5(7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we got one frame per second processing speed.</p>\r\n\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe height=563 width=795 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" seamless frameborder=0 scrolling=no></iframe>\r\n<p>5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.</p>\r\n\r\n<h3>Conclusion</h3>\r\n<ul>\r\n<li>\r\n    <code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.\r\n</li>\r\n<li>\r\n    <code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.\r\n</li>\r\n<li>\r\n    <code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.\r\n</li>\r\n<li>\r\n    <code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.\r\n</li>\r\n</ul>\r\nThere are plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The take away point from this post is that we can easily do image processing in real time using Jetson TK1 for upto 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-11 22:53:46','2014-06-11 22:53:46','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5845,7,'2014-06-12 15:57:27','2014-06-12 15:57:27','[content_band inner_container=\"true\" no_margin=\"true\" border=\"bottom\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-half\"] [custom_headline type=\"left\" level=\"h3\" ]About[/custom_headline]ArrayFire is the software shop for CUDA and OpenCL. Since 2007, ArrayFire has offered the most productive solutions for accelerating code using GPUs. Today, ArrayFire delivers products which are used to accelerate C, C++, and Fortran codes on CUDA GPUs and OpenCL devices. ArrayFire has thousands of customers. These customers come from a wide range of industries, including defense and intelligence, life science, oil and gas, finance, manufacturing, media, and others.\r\n\r\nArrayFire has had success accelerating numerous application types, including math and numerical algorithms, image processing, signal processing, statistics, optimization, and more. Many ArrayFire customers are realizing 100X speed-up with much less effort than is typically required to accelerate code.[/column][column type=\"one-half\" last=\"true\" fade=\"true\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/dj-Flame.png\"] [/column]\r\n<div id=\"contact\"></div>\r\n[line][column type=\"one-third\"][custom_headline type=\"center\" level=\"h5\" accent=\"false\"]Email[/custom_headline]\r\n<p style=\"text-align: center;\">Sales: sales@arrayfire.com\r\nSupport: sales@arrayfire.com\r\nCareers: jobs@arrayfire.com[/column]</p>\r\n[column type=\"one-third\"][custom_headline type=\"center\" level=\"h5\" accent=\"false\"]Phone[/custom_headline]\r\n<p style=\"text-align: center;\">Sales: +1 (800) 570-1941 x 1\r\nTechnical Support: +1 (800) 570-1941 x 2 [/column]</p>\r\n[column type=\"one-third\" last=\"true\"][custom_headline type=\"center\" level=\"h5\" accent=\"false\"]Headquarters[/custom_headline]\r\n<p style=\"text-align: center;\">3405 Piedmont Rd NE STE 100\r\nAtlanta, GA 30305[/column] [/content_band]</p>\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\" ][column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\" ]Careers[/custom_headline]As a global leader in GPU computing software, our business opportunities are always expanding. We are constantly searching for talented, qualified individuals to join the ArrayFire team. ArrayFire is committed to providing employees with the opportunity to grow and learn, the freedom to express ideas and contribute to new developments, and the motivation to succeed. To start the application process, simply email us your resume and let us know which position(s) you\'re interested in.[/column][column type=\"one-half\" last=\"true\"][/column]\r\n\r\n&nbsp;\r\n\r\n[column type=\"one-third\"][promo image=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/little-boba-fett.png\" alt=\"Alt Text\"][custom_headline type=\"left\" level=\"h5\"  class=\"mtn\"]Software Engineer - Atlanta, GA[/custom_headline]\r\n\r\n<strong>Responsibilities:</strong> Develop in C/C++, Fortran, CUDA, and OpenCL. Respond to forum posts and customer support tickets.\r\n\r\n<strong>Qualifications</strong>: A background in any of high-performance computing, operating systems, or compilers. Several years of C/C++ and at least one year of CUDA or similar technology. Familiarity with Fortran is a plus. Undergraduate or graduate work in CS or related field. [/promo][/column]\r\n\r\n[column type=\"one-third\"][promo image=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/uncle-sam.png\" alt=\"Alt Text\"] [custom_headline type=\"left\" level=\"h5\"  class=\"mtn\"]Application Engineer - Atlanta, GA[/custom_headline]\r\n\r\n<strong>Responsibilities: </strong>Work closely with customers to develop software solutions using our products. Develop technical marketing materials including demos, webinars, tutorials, etc. Respond to forum posts and customer support tickets.\r\n\r\n<strong>Qualifications:</strong> Undergraduate or graduate work in CS or related field. Strong programming skills in C/C++. Excellent communication skills.[/promo][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][promo image=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/i-see-pride-i-see-power.png\" alt=\"Alt Text\"][custom_headline type=\"left\" level=\"h5\" class=\"mtn\"]Web/Dev Engineer - Atlanta, GA[/custom_headline]\r\n\r\n<strong>Responsibilities: </strong>Develop PHP/MySQL backend infrastructure with basic HTML/CSS/JavaScript frontend work. Developing lightweight webapps for system monitoring. Maintaining Wordpress and SalesForce integration. Maintaining server/cluster infrastructure.\r\n\r\n<strong>Qualifications:</strong> Strong PHP and MySQL experience. Very comfortable at a shell prompt. Proficient in HTML, CSS, and JavaScript. Familiarity with Wordpress or SalesForce is a plus.[/promo][/column][/content_band]','Company','','inherit','open','open','','329-revision-v1','','','2014-06-12 15:57:27','2014-06-12 15:57:27','',329,'http://sandbox.arrayfire.com/329-revision-v1/',0,'revision','',0),(5847,6,'2014-06-12 18:26:39','2014-06-12 18:26:39','In this post, we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitched the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for upto 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-autosave-v1','','','2014-06-12 18:26:39','2014-06-12 18:26:39','',5799,'http://sandbox.arrayfire.com/5799-autosave-v1/',0,'revision','',0),(5848,6,'2014-06-12 18:26:31','2014-06-12 18:26:31','In this post, we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitched the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for upto 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 18:26:31','2014-06-12 18:26:31','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5849,6,'2014-06-12 18:30:01','2014-06-12 18:30:01','In this post, we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitched the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 18:30:01','2014-06-12 18:30:01','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5850,7,'2014-06-12 18:34:35','2014-06-12 18:34:35','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\n<ul>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a></li>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a></li>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a></li>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\n</ul>\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\n<table>\n<thead>\n<tr class=\"header\">\n<th style=\"text-align: left;\">Property Name / Device Name</th>\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\n<th style=\"text-align: left;\">GT 650M</th>\n</tr>\n</thead>\n<tbody>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Compute</td>\n<td style=\"text-align: left;\">3.2</td>\n<td style=\"text-align: left;\">3.0</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Number of multiprocessors</td>\n<td style=\"text-align: left;\">1</td>\n<td style=\"text-align: left;\">2</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Cores</td>\n<td style=\"text-align: left;\">192</td>\n<td style=\"text-align: left;\">384</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Base clock rate</td>\n<td style=\"text-align: left;\">852 MHz</td>\n<td style=\"text-align: left;\">950 MHz</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Total global memory</td>\n<td style=\"text-align: left;\">1746 MB</td>\n<td style=\"text-align: left;\">2048 MB</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Total shared memory per block</td>\n<td style=\"text-align: left;\">48 KB</td>\n<td style=\"text-align: left;\">48 KB</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Total constant memory</td>\n<td style=\"text-align: left;\">64 KB</td>\n<td style=\"text-align: left;\">64KB</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Memory clock rate</td>\n<td style=\"text-align: left;\">924 MHz</td>\n<td style=\"text-align: left;\">900 MHz</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Memory bus width</td>\n<td style=\"text-align: left;\">64-bit</td>\n<td style=\"text-align: left;\">128-bit</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Total registers per block</td>\n<td style=\"text-align: left;\">32768</td>\n<td style=\"text-align: left;\">65536</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Warp size</td>\n<td style=\"text-align: left;\">32</td>\n<td style=\"text-align: left;\">32</td>\n</tr>\n</tbody>\n</table>\n<h3 id=\"benchmarks\">Benchmarks</h3>\nImages with the the following resolutions are used for benchmarks.\n<ul>\n	<li>480p (720x480)</li>\n	<li>720p and 1080p HD</li>\n	<li>4K and 8K UHD</li>\n</ul>\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\n<h4 id=\"median-filter\">Median Filter</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\n<h4 id=\"resize\">Resize</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nWe benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\n<h4 id=\"histogram\">Histogram</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nStandard 256 bin <code><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\n<h4 id=\"convolution\">Convolution</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\n<h3>Conclusion</h3>\n<ul>\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\n</ul>\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\n\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-autosave-v1','','','2014-06-12 18:34:35','2014-06-12 18:34:35','',5799,'http://sandbox.arrayfire.com/5799-autosave-v1/',0,'revision','',0),(5851,7,'2014-06-12 18:36:27','2014-06-12 18:36:27','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.accelereyes.com/arrayfire/c/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.accelereyes.com/arrayfire/c/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 18:36:27','2014-06-12 18:36:27','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5852,17728,'2014-06-12 18:51:05','2014-06-12 18:51:05','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function. Note that for the 4320p resolution, we achieved one frame per second processing speed.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 18:51:05','2014-06-12 18:51:05','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5853,17728,'2014-06-30 15:50:26','2014-06-30 15:50:26','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\n<ul>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\">Erosion/Dilation</a></li>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\">Resize</a></li>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">Histogram</a></li>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\n</ul>\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\n<table>\n<thead>\n<tr class=\"header\">\n<th style=\"text-align: left;\">Property Name / Device Name</th>\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\n<th style=\"text-align: left;\">GT 650M</th>\n</tr>\n</thead>\n<tbody>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Compute</td>\n<td style=\"text-align: left;\">3.2</td>\n<td style=\"text-align: left;\">3.0</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Number of multiprocessors</td>\n<td style=\"text-align: left;\">1</td>\n<td style=\"text-align: left;\">2</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Cores</td>\n<td style=\"text-align: left;\">192</td>\n<td style=\"text-align: left;\">384</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Base clock rate</td>\n<td style=\"text-align: left;\">852 MHz</td>\n<td style=\"text-align: left;\">950 MHz</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Total global memory</td>\n<td style=\"text-align: left;\">1746 MB</td>\n<td style=\"text-align: left;\">2048 MB</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Total shared memory per block</td>\n<td style=\"text-align: left;\">48 KB</td>\n<td style=\"text-align: left;\">48 KB</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Total constant memory</td>\n<td style=\"text-align: left;\">64 KB</td>\n<td style=\"text-align: left;\">64KB</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Memory clock rate</td>\n<td style=\"text-align: left;\">924 MHz</td>\n<td style=\"text-align: left;\">900 MHz</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Memory bus width</td>\n<td style=\"text-align: left;\">64-bit</td>\n<td style=\"text-align: left;\">128-bit</td>\n</tr>\n<tr class=\"even\">\n<td style=\"text-align: left;\">Total registers per block</td>\n<td style=\"text-align: left;\">32768</td>\n<td style=\"text-align: left;\">65536</td>\n</tr>\n<tr class=\"odd\">\n<td style=\"text-align: left;\">Warp size</td>\n<td style=\"text-align: left;\">32</td>\n<td style=\"text-align: left;\">32</td>\n</tr>\n</tbody>\n</table>\n<h3 id=\"benchmarks\">Benchmarks</h3>\nImages with the the following resolutions are used for benchmarks.\n<ul>\n	<li>480p (720x480)</li>\n	<li>720p and 1080p HD</li>\n	<li>4K and 8K UHD</li>\n</ul>\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\n<h4 id=\"median-filter\">Median Filter</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\n<h4 id=\"resize\">Resize</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nWe benchmarked <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\n<h4 id=\"histogram\">Histogram</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nStandard 256 bin <code><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function.\n<h4 id=\"convolution\">Convolution</h4>\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\n<h3>Conclusion</h3>\n<ul>\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\n	<li><code>bilateral</code> runs in real time until 1080p HD resolution and falls to 8 fps for 4k UHD.</li>\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\n</ul>\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\n\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.\n\n<h4> Update </h4>\n\nWe\'ve released ArrayFire for Jetson TK1. You can <a href=\"http://sandbox.arrayfire.com/download\">download','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-autosave-v1','','','2014-06-30 15:50:26','2014-06-30 15:50:26','',5799,'http://sandbox.arrayfire.com/5799-autosave-v1/',0,'revision','',0),(5854,17729,'2014-06-12 21:17:21','2014-06-12 21:17:21','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 720p HD resolution and falls to interactive rates for 1080p HD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 21:17:21','2014-06-12 21:17:21','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5855,17729,'2014-06-12 21:23:26','2014-06-12 21:23:26','In this post we will be looking at benchmarks of the following ArrayFire image processing functions on an ARM device.\r\n<ul>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\">Erosion/Dilation</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\">Median filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\">Resize</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">Histogram</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\">Bilateral filter</a></li>\r\n	<li><a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\">Convolution</a></li>\r\n</ul>\r\nWe pitted the brand new compute 3.2 GPU on NVIDIA Jetson TK1 against a mobile NVIDIA GPU. The closest match to the GPU (from here on referred as TK1) on the Jetson board we have in our mobile card deck is a NVIDIA GT 650M. The GPU device properties that have critical effect on the function performance are listed below.\r\n<table>\r\n<thead>\r\n<tr class=\"header\">\r\n<th style=\"text-align: left;\">Property Name / Device Name</th>\r\n<th style=\"text-align: left;\">Jetson TK1 GK20A</th>\r\n<th style=\"text-align: left;\">GT 650M</th>\r\n</tr>\r\n</thead>\r\n<tbody>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Compute</td>\r\n<td style=\"text-align: left;\">3.2</td>\r\n<td style=\"text-align: left;\">3.0</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Number of multiprocessors</td>\r\n<td style=\"text-align: left;\">1</td>\r\n<td style=\"text-align: left;\">2</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Cores</td>\r\n<td style=\"text-align: left;\">192</td>\r\n<td style=\"text-align: left;\">384</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Base clock rate</td>\r\n<td style=\"text-align: left;\">852 MHz</td>\r\n<td style=\"text-align: left;\">950 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total global memory</td>\r\n<td style=\"text-align: left;\">1746 MB</td>\r\n<td style=\"text-align: left;\">2048 MB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total shared memory per block</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n<td style=\"text-align: left;\">48 KB</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Total constant memory</td>\r\n<td style=\"text-align: left;\">64 KB</td>\r\n<td style=\"text-align: left;\">64KB</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Memory clock rate</td>\r\n<td style=\"text-align: left;\">924 MHz</td>\r\n<td style=\"text-align: left;\">900 MHz</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Memory bus width</td>\r\n<td style=\"text-align: left;\">64-bit</td>\r\n<td style=\"text-align: left;\">128-bit</td>\r\n</tr>\r\n<tr class=\"even\">\r\n<td style=\"text-align: left;\">Total registers per block</td>\r\n<td style=\"text-align: left;\">32768</td>\r\n<td style=\"text-align: left;\">65536</td>\r\n</tr>\r\n<tr class=\"odd\">\r\n<td style=\"text-align: left;\">Warp size</td>\r\n<td style=\"text-align: left;\">32</td>\r\n<td style=\"text-align: left;\">32</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<h3 id=\"benchmarks\">Benchmarks</h3>\r\nImages with the the following resolutions are used for benchmarks.\r\n<ul>\r\n	<li>480p (720x480)</li>\r\n	<li>720p and 1080p HD</li>\r\n	<li>4K and 8K UHD</li>\r\n</ul>\r\nNote that the vertical axis (Frames per second) in all of the plots is on log scale. The higher the value along the vertical axis, the better the run times are for that function on a given device.\r\n<h4 id=\"erosiondilation\">Erosion/Dilation</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1799759820\" width=\"792\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__morph__mat.htm\"><code>erode</code></a> function. Dilate results will be similar to erode because they use the same algorithm with a different local neighborhood operator.\r\n<h4 id=\"median-filter\">Median Filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=629321992\" width=\"794\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 3x3 mask was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__medfilt.htm\"><code>medfilt</code></a> function as well.\r\n<h4 id=\"resize\">Resize</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=1318972511\" width=\"793\" height=\"561\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe benchmarked <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__resize.htm\"><code>resize</code></a> for halving the image size.\r\n<h4 id=\"histogram\">Histogram</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=12968102\" width=\"794\" height=\"566\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nStandard 256 bin <code><a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__histogram.htm\">histogram</a>.</code>\r\n<h4 id=\"bilateral-filter\">Bilateral filter</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=528280719\" width=\"792\" height=\"560\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nWe used 3.5 (7x7 window) spatial variance and 50 chromatic variance to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__func__cpp__bilateral.htm\"><code>bilateral</code></a> function.\r\n<h4 id=\"convolution\">Convolution</h4>\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1HMKSexMq_G8o8OKtVYq6lpuoezDVNJ2JwNfOS_h-5u8/gviz/chartiframe?oid=905426513\" width=\"795\" height=\"563\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nA 5x5 blur kernel was used to benchmark <a href=\"http://www.sandbox.arrayfire.com/docs/group__signal__func__cpp__convolve.htm\"><code>convolve</code></a> function.\r\n<h3>Conclusion</h3>\r\n<ul>\r\n	<li><code>erode</code>, <code>resize</code> and <code>conv</code> run in real time for all resolutions except 8K UHD.</li>\r\n	<li><code>medfilt</code> runs in real time until 1080p HD resolution and falls to interactive rates for 4K UHD.</li>\r\n	<li><code>bilateral</code> runs in real time until 1080p HD resolution and falls to 8 fps for 4k UHD.</li>\r\n	<li><code>histogram</code> run times are good enough for it to be used in any photo editing software without noticing any lag for generating image histograms.</li>\r\n</ul>\r\nThere are a plethora of other image processing functions available in ArrayFire. You can find the complete list of the functions available in our documentation <a href=\"http://www.sandbox.arrayfire.com/docs/group__image__mat.htm\">here</a>. The main take away point from this post is that we can easily do image processing in real time using Jetson TK1 for up to 4k UHD resolution.\r\n\r\nIf you want to try out ArrayFire on your Jetson TK1, please contact us at sales@arrayfire.com.','Image Processing Benchmarks on NVIDIA Jetson TK1','','inherit','open','open','','5799-revision-v1','','','2014-06-12 21:23:26','2014-06-12 21:23:26','',5799,'http://sandbox.arrayfire.com/5799-revision-v1/',0,'revision','',0),(5857,17795,'2014-06-18 04:23:54','2014-06-18 04:23:54','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other. Even though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear. For the Harris detector, ArrayFire is at least <strong>16 times faster</strong> than the CPU implementation. For the FAST feature detector, ArrayFire is <strong>3-5 times faster</strong> for a smaller number of features, but is <strong>8-10 times faster</strong> when the number of features requested is higher.  \r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','publish','open','open','','computer-vision-arrayfire-part-1','','','2014-06-18 05:06:18','2014-06-18 05:06:18','',0,'http://sandbox.arrayfire.com/?p=5857',0,'post','',6),(5858,17728,'2014-06-17 21:08:57','2014-06-17 21:08:57','NVIDIA has launched their next generation GPU based on their <a title=\"Kepler news release\" href=\"http://nvidianews.nvidia.com/Releases/NVIDIA-Launches-First-GeForce-GPUs-Based-on-Next-Generation-Kepler-Architecture-79b.aspx\" target=\"_blank\">Kepler Architecture</a>. They followed it up with a rather quick update to their <a title=\"CUDA toolkit\" href=\"http://developer.nvidia.com/cuda-downloads\" target=\"_blank\">CUDA toolkit</a>. Considering that we have access to 3 generations of their GTX cards (480, 580 and 680), we thought we would show case how the performance has changed over the generations.\n\n<strong> Matrix multiplication</strong>:\n\n<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/matmul.png\"><img class=\"aligncenter size-full wp-image-2561\" title=\"matmul\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/matmul.png\" alt=\"One terra flops!\" width=\"600\" height=\"300\" /></a>\n\nIt can be seen that the GTX 680 breaches the 1 Terraflop mark comfortably for single precision, while the GTX 580 barely scratches it. However the performance seems to peak around 2048 x 2048 and then rallies downward to match the performance of the GTX 580 at larger sizes. The high end Tesla C2070 finishes last for single precision behind the third placed GTX 480.\n\nFor double precision, as expected the C2070 is well ahead of the pack. The most interesting snippet here is that the GTX 680, finishes <em>dead last</em> compared to its predecessors. At about 1/10 th  of its single precision performance, <em>the 680 is about twice as slow as the 580</em> which settles down a ~ 1/5th the single precision performance.\n\n<strong>Fast Fourier Transform</strong>:\n\n<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/fft2d1.png\"><img class=\"aligncenter size-full wp-image-2575\" title=\"fft2d\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/fft2d1.png\" alt=\"Fast fast aww no more memory!\" width=\"600\" height=\"300\" /></a>The performance gains moving from 480 to a 580 is significant (~20%), while the 680 does not seem to have huge wins over its immediate predecessor. The Fast Fourier Transform is an interesting benchmark in that, it is a case of these cards running out of memory before the peak performance is reached. At 2GB, the 680 can hold two 8192x8192 single precision, complex matrices, but the scratch space required for this algorithm is more than the free space available. All the transformations were 2D , Real to complex transforms.\n\n<strong>SORT</strong>:\n\n<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/sort.png\"><img class=\"aligncenter\" title=\"sort\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2012/04/sort.png\" alt=\"\" width=\"600\" height=\"300\" /></a>Here the GTX 680 starts off strong before losing out to the GTX 580, and eventually to the 480.  We are using the same <a href=\"http://code.google.com/p/back40computing/wiki/RadixSorting\" target=\"_blank\">radix-sort</a> algorithm for all the benchmarks.  It is really astonishing that the 680 is more than 20% slower at peak.\n\nResources:\n\n<a href=\"https://gist.github.com/2493843\" target=\"_blank\">Benchmark Code</a>\n\n<a href=\"https://docs.google.com/spreadsheet/ccc?key=0AitC5fE6lOMzdHB3eGxNQzlidlFLbjBzSlZtbG8zLWc\" target=\"_blank\">Benchmark Results </a>\n\nRelated links:\n\n<a href=\"http://www.tomshardware.com/reviews/geforce-gtx-680-review-benchmark,3161-15.html\" target=\"_blank\">Tom\'s hardware: LuxMark Benchmarks</a>\n\n<a href=\"http://www.anandtech.com/show/5699/nvidia-geforce-gtx-680-review\" target=\"_blank\">Anandtech: Retaking the performance crown</a>\n\n&nbsp;\n\n&nbsp;','Benchmarking the new Kepler (GTX 680)','','inherit','open','open','','2557-revision-v1','','','2014-06-17 21:08:57','2014-06-17 21:08:57','',2557,'http://sandbox.arrayfire.com/2557-revision-v1/',0,'revision','',0),(5859,17728,'2014-06-17 21:10:29','2014-06-17 21:10:29','In this blog post, we are going to compare NVIDIA\'s latest high end offering, the <a title=\"Tesla KSeries Overview\" href=\"http://www.nvidia.com/content/PDF/kepler/Tesla-KSeries-Overview-LR.pdf\">Tesla K series</a> (PDF) with their previous offering. In particular we are comparing the Tesla K20C with Tesla C2070/2075.\n\nThis blog post follows a similar post about <a title=\"Benchmarking the GTX 680\" href=\"http://blog.accelereyes.com/blog/2012/04/26/benchmarking-kepler-gtx-680/\">benchmarking the GTX680</a> we did last year. We take a look at similar set of functions (and a little bit more) to see what benefits the newer line brings.\n\nAll of the benchmarks were done using <strong>double precision</strong>. In all of the graphs, higher trendlines are better.\n\n<strong>Matrix Multiplication</strong>\n\n<img class=\"size-full wp-image-3461   aligncenter\" title=\"Matrix_Multiply\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/matmul.png\" width=\"609\" height=\"365\" />\n\nIn house at AccelerEyes, we use matrix multiplication as the gold standard for testing the maximum performance of all new GPUs we end up with. The K20c reaches a peak at about <strong>1 TFLOPs for <strong>Double Precision</strong>.</strong> This is about 85% of maximum theoretical performance of 1.2 TFLOPS ^.  The c2070 reaches about 310 GFLOPS, a mere 60% of maximum theoretical performance of 515 GFLOPS. In effect, <strong>the K20 is 3 times faster than the C2070</strong>.\n\n<strong>Linear Algebra</strong>\n\n<img class=\"size-full wp-image-3460 aligncenter\" alt=\"linalg\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/linalg.png\" width=\"605\" height=\"340\" />\n\nContinuing to other linear algebra functions from matrix multiply, we see that the K20 still beats the C2070 by about 2.5x. You may also notice that LU decomposition is slower on the K20 at smaller sizes. We are unsure about the actual reasons, but let us present all the info we have. The GPUs were on different machines using different motherboards with possibly different PCIe speeds.  This is relevant because small chunks of data is transferred to the host for faster computation. At smaller sizes, the data transfers and the computation on the CPU become the bottleneck. Hence it may be unfair to compare the GPUs across various systems at these sizes.\n\n<strong>Fast Fourier Transform</strong>\n\n&nbsp;\n\n<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/fft21.png\"><img class=\"size-full wp-image-3463 aligncenter\" alt=\"fft2\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/fft21.png\" width=\"605\" height=\"340\" /></a>\n\nIn this particular case, the K20c is about <strong>1.6x faster</strong> than the c2070. The absolute numbers are not relevant here because the formula used to calculate GFLOPs for FFTs (5 * N * log(N)) is only approximate, and the constant factor may be higher or lower than 5 depending on the algorithm utilized.\n\n<strong>Sort</strong>\n\n<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/sort2.png\"><img class=\"size-full wp-image-3465 aligncenter\" alt=\"sort\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/02/sort2.png\" width=\"605\" height=\"340\" /></a>\n\n&nbsp;\n\nAlthough the K20 starts off a little bit slower, the performance keeps increasing at a steeper incline than that of the C2070. The older Tesla seems to be approaching its limit at 165 million keys per second, where as the K20 is still going strong at the end of the test coming in at about 500 million keys per second. This is about <strong>3x faster </strong>than the C2070.\n\nAll the above benchmarks have been done using arrayfire 1.9 which uses cuda 5.0.\n\n^Ref:  <a href=\"http://www.nvidia.com/object/tesla-servers.html\">http://www.nvidia.com/object/tesla-servers.html</a>\n<h6 class=\"zemanta-related-title\" style=\"font-size: 1em;\">Related articles</h6>\n<ul class=\"zemanta-article-ul zemanta-article-ul-image\" style=\"margin: 0; padding: 0; overflow: hidden;\">\n	<li class=\"zemanta-article-ul-li-image zemanta-article-ul-li\" style=\"padding: 0; background: none; list-style: none; display: block; float: left; vertical-align: top; text-align: left; width: 84px; font-size: 11px; margin: 2px 10px 10px 2px;\"><a style=\"box-shadow: 0px 0px 4px #999; padding: 2px; display: block; border-radius: 2px; text-decoration: none;\" href=\"http://marchamilton.wordpress.com/2013/02/12/nvida-kepler-gpu-momentum/\" target=\"_blank\"><img style=\"padding: 0; margin: 0; border: 0; display: block; width: 80px; max-width: 100%;\" alt=\"\" src=\"http://i.zemanta.com/144876549_80_80.jpg\" /></a><a style=\"display: block; overflow: hidden; text-decoration: none; line-height: 12pt; height: 80px; padding: 5px 2px 0 2px;\" href=\"http://marchamilton.wordpress.com/2013/02/12/nvida-kepler-gpu-momentum/\" target=\"_blank\">Nvida Kepler GPU Momentum</a></li>\n	<li class=\"zemanta-article-ul-li-image zemanta-article-ul-li\" style=\"padding: 0; background: none; list-style: none; display: block; float: left; vertical-align: top; text-align: left; width: 84px; font-size: 11px; margin: 2px 10px 10px 2px;\"><a style=\"box-shadow: 0px 0px 4px #999; padding: 2px; display: block; border-radius: 2px; text-decoration: none;\" href=\"http://insidehpc.com/2013/02/16/nvidia-adds-new-cuda-education-centers-beefs-up-program-rewards/\" target=\"_blank\"><img style=\"padding: 0; margin: 0; border: 0; display: block; width: 80px; max-width: 100%;\" alt=\"\" src=\"http://i.zemanta.com/145898865_80_80.jpg\" /></a><a style=\"display: block; overflow: hidden; text-decoration: none; line-height: 12pt; height: 80px; padding: 5px 2px 0 2px;\" href=\"http://insidehpc.com/2013/02/16/nvidia-adds-new-cuda-education-centers-beefs-up-program-rewards/\" target=\"_blank\">Nvidia Adds New Cuda Education Centers, Beefs up Program Rewards</a></li>\n	<li class=\"zemanta-article-ul-li-image zemanta-article-ul-li\" style=\"padding: 0; background: none; list-style: none; display: block; float: left; vertical-align: top; text-align: left; width: 84px; font-size: 11px; margin: 2px 10px 10px 2px;\"><a style=\"box-shadow: 0px 0px 4px #999; padding: 2px; display: block; border-radius: 2px; text-decoration: none;\" href=\"http://kotaku.com/5985262/whats-most-impressive-about-nvidias-new-1000-graphics-card-how-it-sounds\" target=\"_blank\"><img style=\"padding: 0; margin: 0; border: 0; display: block; width: 80px; max-width: 100%;\" alt=\"\" src=\"http://i.zemanta.com/146477186_80_80.jpg\" /></a><a style=\"display: block; overflow: hidden; text-decoration: none; line-height: 12pt; height: 80px; padding: 5px 2px 0 2px;\" href=\"http://kotaku.com/5985262/whats-most-impressive-about-nvidias-new-1000-graphics-card-how-it-sounds\" target=\"_blank\">What\'s Most Impressive About Nvidia\'s New $1,000 Graphics Card? How It Sounds.</a></li>\n	<li class=\"zemanta-article-ul-li-image zemanta-article-ul-li\" style=\"padding: 0; background: none; list-style: none; display: block; float: left; vertical-align: top; text-align: left; width: 84px; font-size: 11px; margin: 2px 10px 10px 2px;\"><a style=\"box-shadow: 0px 0px 4px #999; padding: 2px; display: block; border-radius: 2px; text-decoration: none;\" href=\"http://www.hpcwire.com/hpcwire/2013-01-31/nvidia_super_sets_energy-efficiency_record.html\" target=\"_blank\"><img style=\"padding: 0; margin: 0; border: 0; display: block; width: 80px; max-width: 100%;\" alt=\"\" src=\"http://i.zemanta.com/142009547_80_80.jpg\" /></a><a style=\"display: block; overflow: hidden; text-decoration: none; line-height: 12pt; height: 80px; padding: 5px 2px 0 2px;\" href=\"http://www.hpcwire.com/hpcwire/2013-01-31/nvidia_super_sets_energy-efficiency_record.html\" target=\"_blank\">NVIDIA Super Sets Energy-Efficiency Record</a></li>\n	<li class=\"zemanta-article-ul-li-image zemanta-article-ul-li\" style=\"padding: 0; background: none; list-style: none; display: block; float: left; vertical-align: top; text-align: left; width: 84px; font-size: 11px; margin: 2px 10px 10px 2px;\"><a style=\"box-shadow: 0px 0px 4px #999; padding: 2px; display: block; border-radius: 2px; text-decoration: none;\" href=\"http://www.hpcwire.com/hpcwire/2013-02-05/gpu_wars.html\" target=\"_blank\"><img style=\"padding: 0; margin: 0; border: 0; display: block; width: 80px; max-width: 100%;\" alt=\"\" src=\"http://i.zemanta.com/143200694_80_80.jpg\" /></a><a style=\"display: block; overflow: hidden; text-decoration: none; line-height: 12pt; height: 80px; padding: 5px 2px 0 2px;\" href=\"http://www.hpcwire.com/hpcwire/2013-02-05/gpu_wars.html\" target=\"_blank\">GPU Wars</a></li>\n</ul>\n<div class=\"zemanta-pixie\" style=\"margin-top: 10px; height: 15px;\"><img class=\"zemanta-pixie-img\" style=\"border: none; float: right;\" alt=\"\" src=\"http://img.zemanta.com/pixy.gif?x-id=da0522c3-5691-48a0-b749-6c3993bf7ac3\" /></div>','Benchmarking Tesla K20','','inherit','open','open','','3458-revision-v1','','','2014-06-17 21:10:29','2014-06-17 21:10:29','',3458,'http://sandbox.arrayfire.com/3458-revision-v1/',0,'revision','',0),(5860,17728,'2014-06-17 21:11:45','2014-06-17 21:11:45','The increasing availability of high performance image processing hardware, such as GPUs, and quality video sensors has opened up exciting possibilities for video processing. One such area of interest is extracting moving targets from real-time video streams, useful for various computer vision applications such as recognition, tracking, video analysis, and surveillance. It is important to have video processing capabilities that can process such large amounts of data for real-time analysis, as conventional methods are computationally expensive.\r\n\r\n&nbsp;\r\n\r\n[caption id=\"attachment_1650\" align=\"aligncenter\" width=\"615\" caption=\"Processing multiple subwindows in parallel on the GPU; each subwindow processing a moving target candidate\"]<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2011/08/ngc-gfor-hist-4-e1313092762974.png\"><img class=\"size-full wp-image-1650\" title=\"gfor hist() in action\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2011/08/ngc-gfor-hist-4-e1313092762974.png\" alt=\"\" width=\"615\" height=\"377\" /></a>[/caption]\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://www.northropgrumman.com/\" target=\"_blank\">Northrop Grumman Corporation</a> (NYSE: NOC) is a leading global security company with expertise in areas such as unmanned systems, cybersecurity, C4ISR, and logistics. Recently, Northrop Grumman found success using LibJacket to achieve <span style=\"color: #ff0000;\"><em>over <strong>4x</strong> speedup</em></span> of code detecting moving targets in sequenced video frames.\r\n\r\nNGC had a video image sequence of size 2000x2000 that needed advanced temporal image processing performed on consecutive frames, but performance on the CPU was currently lacking. Fortunately for NGC, performing image processing on large images is a task well suited for GPUs, and made easy via <a href=\"http://www.accelereyes.com/libjacket_tour?idx=0\" target=\"_blank\">LibJacket</a>.\r\n\r\n&nbsp;\r\n\r\n[caption id=\"attachment_1651\" align=\"aligncenter\" width=\"634\" caption=\"Mini example of a gfor histogram pipeline processing multiple subwindows\"]<a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2011/08/ngc-gfor-hist-s.png\"><img class=\"size-full wp-image-1651\" title=\"example gfor hist() pipeline\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2011/08/ngc-gfor-hist-s.png\" alt=\"\" width=\"634\" height=\"356\" /></a>[/caption]\r\n\r\n&nbsp;\r\n\r\nOne of the biggest performance boosts NGC gained while modifying their existing C++ code to use LibJacket, came from being able to make good use of LibJacket\'s <strong><a href=\"http://wiki.accelereyes.com/wiki/index.php/GFOR_Usage\" target=\"_blank\">gfor</a></strong> functionality.\r\n\r\nTo highlight one particular instance:\r\n<blockquote>Consider the task of extracting hundreds of small subwindows from an image, computing the cumulative histogram for each subwindow, then searching each histogram to find a threshold for that area, all over a 2K x 2K image as fast as possible.</blockquote>\r\nUsing LibJacket\'s <em>gfor-enabled <a href=\"http://wiki.accelereyes.com/wiki/index.php/Hist\" target=\"_blank\">histogram</a></em>, instead of sequentially performing hundreds of small histograms on the CPU as before, all the subwindowed histograms are combined into a single kernel launch on the GPU to run in parallel. This simple change gained <span style=\"color: #ff0000;\"><em>over <strong>8x</strong> speedup</em></span> for this stage of NGC\'s image processing pipeline, putting the goal of real-time processing within reach.\r\n\r\nAt the time of writing, about 90% of NGC\'s existing CPU moving target detection code has been successfully ported to LibJacket, totaling over 4x improvement in processing time so far. We\'re confidant that NGC will see their performance potential continue to grow.\r\n\r\n&nbsp;\r\n\r\n&nbsp;','Real-Time Moving Target Detection with LibJacket','','inherit','open','open','','1629-autosave-v1','','','2014-06-17 21:11:45','2014-06-17 21:11:45','',1629,'http://sandbox.arrayfire.com/1629-autosave-v1/',0,'revision','',0),(5861,17728,'2014-06-17 21:12:32','2014-06-17 21:12:32','Amazon <a href=\"http://aws.amazon.com/about-aws/whats-new/2010/11/15/announcing-cluster-gpu-instances-for-amazon-ec2/\" target=\"_blank\">recently added</a> GPUs to their Elastic Compute Cloud. We decided to throw <a href=\"http://www.accelereyes.com/products/libjacket\" target=\"_blank\">LIBJACKET</a> into this GPU cloud to see how it would fare. The $2/hr pay-on-demand pricing is a great option for many Jacket programmers.\n\nThis post is full of screenshots detailing the steps we took to get going with GPU computing in Amazon\'s cloud:\n<div>\n<ol>\n	<li>Sign up with Amazon EC2</li>\n	<li>Launch a GPU instance</li>\n	<li>Login to the instance using ssh</li>\n	<li>Setup the environment</li>\n	<li>Download, build, and test LIBJACKET!</li>\n</ol>\n</div>\nEverything in this post applies equally well to running Jacket for MATLAB® on EC2. Simply install MATLAB + Jacket in your Amazon GPU instance and start working over ssh.\n\n<!--more-->\n\n<em>Note: Simply click on the images to make them larger as needed.</em>\n\n1) <strong>Sign up with Amazon EC2</strong>\n<ul>\n	<li>Go to <a href=\"http://aws.amazon.com/ec2/\" target=\"_blank\">http://aws.amazon.com/ec2/</a> and sign up.</li>\n	<li>Once you are done, you will get multiple email notifications from Amazon.</li>\n	<li>Open the email with \"Amazon Elastic Compute Cloud Sign-Up Confirmation\".</li>\n	<li>Navigate to the first link, create the Access keys, and store them in a safe place.</li>\n	<li>Now go to <a href=\"https://console.aws.amazon.com/ec2/home\" target=\"_blank\">https://console.aws.amazon.com/ec2/home</a>.</li>\n	<li>This is where you will be doing most of your work.</li>\n	<li>If you had not created key pairs already, you can create a new key pair as shown below:</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key01.png\"><img class=\"aligncenter size-medium wp-image-908\" title=\"key01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key01.png\" width=\"666\" height=\"520\" /></a></p>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key02.png\"><img class=\"aligncenter size-medium wp-image-909\" title=\"key02\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key02.png\" width=\"666\" height=\"520\" /></a></p>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key03.png\"><img class=\"aligncenter size-medium wp-image-910\" title=\"key03\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/key03.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>At this point you will be prompted to download a .pem key that you will need to use for all future logins.</li>\n</ul>\n2) <strong>Launch a GPU instance</strong>\n<ul>\n	<li>You begin by clicking launch instances in your management console.</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance01.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance01.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Be careful to choose the correct type of instance.</li>\n	<li>To create the GPU cluster, choose the Centos 5.5 instance  (AMI ID: aa30c7c3).</li>\n	<li>Verify that CUDA 3.1 is included.</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance02.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance02.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Next in instance details, choose \"Cluster GPU\" as the instance type.</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance03.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance03.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Use default values for the rest of the fields in Instance details.</li>\n	<li>When prompted to choose the key pair, use the one that you had already downloaded.</li>\n	<li>For the rest of the tutorial, we use \"test_key.pem\" as our key.</li>\n	<li>Replace test_key with the appropriate key name whenever necessary.</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance04.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance04.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Choose default values for the rest. The final review page should look like this:</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance05.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance05.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Congratulations, you now have a GPU instance!</li>\n	<li>Your instance also starts running immediately, So does your billing cycle :)</li>\n</ul>\n3) <strong>Login to the instance using ssh</strong>\n<ul>\n	<li>To connect to your instance, you need to know the IP address associated with your account.</li>\n	<li>For this, click on your instance, choose connect.</li>\n	<li>A popup window opens up giving you the required details.</li>\n</ul>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance06.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance06.png\" width=\"666\" height=\"520\" /></a></p>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance07.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance07.png\" width=\"666\" height=\"520\" /></a></p>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance08.png\"><img class=\"aligncenter size-full wp-image-916\" title=\"instance01\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/instance08.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>Take note that you have set the permissions of test_key.pem to be readable only by you.</li>\n	<li>cd to the directory test_key.pem is located in and use the following commands to ssh into Amazon EC2:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ chmod 400 test_key.pem\n$ ssh -i test_pem root@ec2-xxx-xxx-xxx-xxx.compute-1.amazonaws.com</pre>\n4) <strong>Setup the environment</strong>\n<ul>\n	<li>Once you are logged in poke around a little to get to know a bit about the environment.</li>\n	<li>You could verify if the cuda toolkit and nvidia drivers have been installed:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ ls /usr/local/cuda\n$ cat /proc/driver/nvidia/version</pre>\n<ul>\n	<li>Now coming to setting up the environment, you will have to install a few things.</li>\n	<li>Centos 5.5 comes with gcc 4.1 by default, and libjacket currently has compatibility issues with it.</li>\n	<li>Hence we will be installing gcc 44 and g++ libraries:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ yum install -y gcc-c++ gcc44 gcc44-c++</pre>\n<ul>\n	<li>Now you need to set up the system to use gcc44 , g++44 by default:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ cp /usr/bin/gcc /usr/bin/gcc41; cp /usr/bin/g++ /usr/bin/g++41\n$ rm /usr/bin/gcc /usr/bin/g++\n$ alternatives --install /usr/bin/gcc gcc /usr/bin/gcc44 40\n$ alternatives --install /usr/bin/gcc gcc /usr/bin/gcc41 50\n$ alternatives --install /usr/bin/g++ g++ /usr/bin/g++44 40\n$ alternatives --install /usr/bin/g++ g++ /usr/bin/g++41 50</pre>\n<ul>\n	<li>Now that the alternatives have been set up, you will need to choose the correct version:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ alternatives --config gcc</pre>\n<ul>\n	<li>This will print out a menu on the console. Choose the option that points to gcc44.</li>\n	<li>Repeat the procedure for g++.</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ alternatives --config g++</pre>\n<ul>\n	<li>Now you can verify the gcc and g++ versions by using the following commands:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$ gcc --version\n$ g++ --version</pre>\n<ul>\n	<li>Make sure the version is 4.4.x.</li>\n	<li>Now that gcc is setup, we need to put /usr/local/cuda/bin in .bashrc:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$echo \"export PATH=$PATH:/usr/local/cuda/bin\" &gt;&gt; ~/.bashrc</pre>\n<ul>\n	<li>Now you are all set and can begin working with LIBJACKET!</li>\n</ul>\n<strong>5.  Download, build, and test LIBJACKET!</strong>\n<ul>\n	<li>Download LIBJACKET</li>\n</ul>\n<pre class=\"lang:default decode:true\">$wget -c http://www.accelereyes.com/nightly/libjacket-linux-DEV.tgz</pre>\n<ul>\n	<li>Extract it:</li>\n</ul>\n<pre class=\"lang:default decode:true\">$tar xvzf libjacket-linux-DEV.tgz</pre>\n<ul>\n	<li>Test it!</li>\n</ul>\n&nbsp;\n<pre class=\"lang:default decode:true\">$cd libjacket/examples/pi\n$make run</pre>\n<p style=\"text-align: center;\"><a href=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/final1.png\"><img class=\"aligncenter size-full wp-image-935\" title=\"final\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2010/12/final1.png\" width=\"666\" height=\"520\" /></a></p>\n\n<ul>\n	<li>LIBJACKET yielded a <span style=\"color: #ff0000;\">44X speedup</span> for this example!</li>\n</ul>\n<!--more-->Notes:\n<ul>\n	<li>Do not forget to go back to the management console to stop the instance once you are done working with it.</li>\n	<li>You will be assigned a new IP every time you stop and start an instance. There may be ways around it, we have not explored it yet.</li>\n	<li>Setting up the whole thing took about one hour\'s work. Most of the time being spent to figure out gcc issues.</li>\n	<li><a href=\"http://kenneth.kufluk.com/blog/2010/03/getting-started-with-amazon-ec2/\" target=\"_blank\">Here</a> is a nice post that was really helpful to us in about getting started with EC2</li>\n</ul>','LIBJACKET on Amazon EC2 GPU Cloud Instances','','inherit','open','open','','907-revision-v1','','','2014-06-17 21:12:32','2014-06-17 21:12:32','',907,'http://sandbox.arrayfire.com/907-revision-v1/',0,'revision','',0),(5863,17728,'2014-06-17 21:15:28','2014-06-17 21:15:28','With the rise of GPU computing over the last few years, it is not surprising that <a href=\"http://blogs.nvidia.com/2011/11/gpu-supercomputers-show-exponential-growth-in-top500-list/\">more than 30</a> super computers are now powered by GPUs. Add to that Amazon ECC now offers <a href=\"http://aws.amazon.com/ec2/\">GPU instances</a> that have two GPUs per node, it is now easy to set up a cluster of your own and run simulations using a large number of GPUs. The availability of these clusters and the proven performance of GPUs over the last couple of years has led many researchers, and businesses to move from testing GPUs to scaling their problems to multiple GPUs.\n\nAs a consequence of this,  we have a lot of our customers want to know how to scale our products across multiple GPUs. So in this post we would like to show you a brief description of what is happening when you call gpu enabled functions. We will then discuss how this knowledge can be used to scale you problems in the best possible manner.\n\nWha\n\n&nbsp;','Multi GPU programming','','inherit','open','open','','2616-revision-v1','','','2014-06-17 21:15:28','2014-06-17 21:15:28','',2616,'http://sandbox.arrayfire.com/2616-revision-v1/',0,'revision','',0),(5877,17728,'2014-06-17 21:33:09','2014-06-17 21:33:09','<p style=\"text-align: justify;\">ARM showcased ArrayFire support for the Mali GPU at the Supercomputing \'13 conference recently held in Denver.  This exciting development caught the attention of many attendees as they viewed the ArrayFire demos running in the ARM and AccelerEyes exhibits.</p>\r\n\r\n\r\n[caption id=\"attachment_4593\" align=\"aligncenter\" width=\"717\"]<img alt=\"Visitors to the AccelerEyes exhibit check out the ArrayFire OpenCL Demo on ARM Mali at the Supercomputing Conference.\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/12/SC13-Photo-Restroom-shopped.jpg\" width=\"717\" height=\"621\" /> Visitors to the AccelerEyes exhibit check out the ArrayFire OpenCL demo on ARM Mali at the Supercomputing Conference.[/caption]\r\n\r\n&nbsp;\r\n<p style=\"text-align: justify;\">Energy budgets are always constrained, and form an expensive component of any HPC system. ARM Mali GPUs provide the best performance and throughput for a given energy envelope. Partnering with ARM, AccelerEyes further reduces the cost of HPC by minimizing development time and costs.</p>\r\n<p style=\"text-align: justify;\">AccelerEyes offers the most productive software solutions for accelerating code using GPUs, coprocessors, and OpenCL devices.  AccelerEyes delivers ArrayFire to accelerate C, C++, and Fortran codes on CUDA and OpenCL devices.  ArrayFire customers come from a wide range of industries, including defense and intelligence, life science, oil and gas, finance, manufacturing, media, and others. ArrayFire has had success accelerating numerous application types, including math and numerical algorithms, image processing, signal processing, statistics, optimization, and more.</p>\r\n<img class=\"aligncenter\" alt=\"\" src=\"http://blog.accelereyes.com/blog/wp-content/uploads/2013/11/BZdMTEuCMAAaeXJ.jpg\" width=\"412\" height=\"549\" />\r\n<p style=\"text-align: justify;\">Mali GPU users can deploy ArrayFire as a fast, easy-to-use software solution to enable acceleration of their code. ArrayFire now fully supports OpenCL. With ArrayFire v2.0, AccelerEyes has released a demo version of ARM support to select customers. In ArrayFire v2.1, AccelerEyes will make ARM-support an official feature of the ArrayFire library for use on all ARM-enabled platforms.</p>\r\n<p style=\"text-align: justify;\">Stay tuned for future updates as ARM and AccelerEyes continue collaboration on this exciting project!</p>','ARM Showcases ArrayFire OpenCL Support for Mali GPU at Supercomputing \'13','','inherit','open','open','','4580-revision-v1','','','2014-06-17 21:33:09','2014-06-17 21:33:09','',4580,'http://sandbox.arrayfire.com/4580-revision-v1/',0,'revision','',0),(5880,17795,'2014-06-17 22:18:34','2014-06-17 22:18:34','In my previous post <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, I talked a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, combining the FAST feature detector [1] and ORB to extract descriptors [2], descriptor matching will be done with the Hamming function. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, I would like to share our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9, with SSE and CUDA support.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=516496594\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. “A combined corner and edge detector.” Alvey vision conference. Vol. 15. 1988.','Upcoming computer vision algorithms in ArrayFire','','inherit','open','open','','5857-revision-v1','','','2014-06-17 22:18:34','2014-06-17 22:18:34','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5881,17795,'2014-06-17 22:26:52','2014-06-17 22:26:52','In my previous post <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, I talked a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, combining the FAST feature detector [1] and ORB to extract descriptors [2], descriptor matching will be done with the Hamming function. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, I would like to share our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9, with SSE and CUDA support.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=516496594\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1315398688\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. “A combined corner and edge detector.” Alvey vision conference. Vol. 15. 1988.','Upcoming computer vision algorithms in ArrayFire','','inherit','open','open','','5857-revision-v1','','','2014-06-17 22:26:52','2014-06-17 22:26:52','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5882,17795,'2014-06-18 00:05:18','2014-06-18 00:05:18','In my previous post <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, I talked a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, combining the FAST feature detector [1] and ORB to extract descriptors [2], descriptor matching will be done with the Hamming function. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, I will share our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9, with SSE and CUDA support.\r\n\r\n<h3>Benchmarks</h3>\r\n\r\nNOTE: horizontal axes are all on logarithmic scale.\r\n\r\nBelow we see the benchmarks for the FAST feature detector. Note that we measure the speedup according to the number of features found, as FAST scales according to this characteristic.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=516496594\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1315398688\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nDifferent from FAST, the ORB descriptor extractor scales according to the number of pixels of the input image, even though it relies on FAST to detect features.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=13238476\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=55032957\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nFinally, the Hamming matcher benchmarks are below. To perform this measurements, we used a set of 500 descriptors as the test descriptors (e.g., number of descriptors extracted from an image), being matched to a database containing 500 to 5 million descriptors, separated by a factor of 10.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=364250772\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=759093996\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nFrom the \r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. “A combined corner and edge detector.” Alvey vision conference. Vol. 15. 1988.','Upcoming computer vision algorithms in ArrayFire','','inherit','open','open','','5857-revision-v1','','','2014-06-18 00:05:18','2014-06-18 00:05:18','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5883,17795,'2014-06-18 00:23:58','2014-06-18 00:23:58','In my previous post <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, I talked a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, combining the FAST feature detector [1] and ORB to extract descriptors [2], descriptor matching will be done with the Hamming function. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, I will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n\r\n<h3>Benchmarks</h3>\r\n\r\nNote that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\nBelow we see the benchmarks for the FAST feature detector. Note that we measure the speedup according to the number of features found, as FAST scales according to this characteristic.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=516496594\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1315398688\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nDifferent from FAST, the ORB descriptor extractor scales according to the number of pixels of the input image, even though it relies on FAST to detect features.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=13238476\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=55032957\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nFinally, the Hamming matcher benchmarks are below. To perform this measurements, we used a set of 500 descriptors as the test descriptors (e.g., number of descriptors extracted from an image), being matched to a database containing 500 to 5 million descriptors, separated by a factor of 10.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=364250772\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=759093996\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<h3>Discussion</h3>\r\n\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 20 times for ORB and Hamming matching, and up to 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s implementation of the algorithms for CUDA, we see that in almost all cases we are already at least a little bit faster (e.g., up to 1.3x speedup on ORB), but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\n<h3>References</h3>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. “A combined corner and edge detector.” Alvey vision conference. Vol. 15. 1988.','Upcoming computer vision algorithms in ArrayFire','','inherit','open','open','','5857-revision-v1','','','2014-06-18 00:23:58','2014-06-18 00:23:58','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5884,17795,'2014-06-18 02:02:27','2014-06-18 02:02:27','In my previous post <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, I talked a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, combining the FAST feature detector [1] and ORB to extract descriptors [2], descriptor matching will be done with the Hamming function. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, I will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n\r\n<h3>Benchmarks</h3>\r\n\r\nNote that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\nBelow we see the benchmarks for the FAST feature detector. Note that we measure the speedup according to the number of features found, as FAST scales according to this characteristic.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" seamless frameborder=0 scrolling=no></iframe>\r\nDifferent from FAST, the ORB descriptor extractor scales according to the number of pixels of the input image, even though it relies on FAST to detect features.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=303245979\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nFinally, the Hamming matcher benchmarks are below. To perform this measurements, we used a set of 500 descriptors as the test descriptors (e.g., number of descriptors extracted from an image), being matched to a database containing 500 to 5 million descriptors, separated by a factor of 10.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1730737789\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<h3>Discussion</h3>\r\n\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 20 times for ORB and Hamming matching, and up to 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s implementation of the algorithms for CUDA, we see that in almost all cases we are already at least a little bit faster (e.g., up to 1.3x speedup on ORB), but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\n<h3>References</h3>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Upcoming computer vision algorithms in ArrayFire','','inherit','open','open','','5857-revision-v1','','','2014-06-18 02:02:27','2014-06-18 02:02:27','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5885,17795,'2014-07-29 16:58:31','2014-07-29 16:58:31','In the <a href=\"http://sandbox.arrayfire.com/computer-vision-arrayfire-part-1/\">Part 1</a> of this series, we talked about upcoming feature detection algorithms in ArrayFire library. In this post we show case some of the preliminary results of Feature Description and matching that are under development in the ArrayFire library. Feature description is done using the ORB feature descriptor[1]. The descriptors are matched against a database of features using Hamming distance as the metric.\r\n\r\nThe results we show in this blog use the same hardware and software used in the previous blog:\r\n<ul>\r\n	<li>Intel Sandy Bridge Xeon processor with 32 cores (for baseline OpenCV CPU implementation)</li>\r\n	<li>NVIDIA Tesla K20C (for OpenCV and ArrayFire CUDA implementations)</li>\r\n	<li>ArrayFire development version</li>\r\n	<li>OpenCV version 2.4.9</li>\r\n</ul> \r\n\r\n<h3>Feature Description and Matching Benchmarks</h3>\r\nIn Part 1 we showed that feature detection with FAST[2] scales with respect to to the number of features detected. While ORB uses FAST for the feature detection step, it performs additional computations to calculate Harris Corner scores as well as orientation of the features[3]. This results in ORB scaling with the number pixels (meaning it is not bottlenecked by FAST). \r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=303245979\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Hamming matcher benchmarks are shown below. For benchmarking purposes, we used a set of 500 descriptors as test descriptors (e.g., number of descriptors extracted from an image), being matched to a database containing 500 to 5 million descriptors, each step increasing by an order of magnitude.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1730737789\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Descriptor Matching Samples</h3>\r\nIn this section we show an image matching of the Lena image with a 90 degrees rotation of Lena. The top set uses ArrayFire and the bottom set uses OpenCV. There is also a green rectangle around the matched pictures, that indicated the homography of the detected object.\r\n<p style=\"text-align: center;\"><em>ORB with ArrayFire, 21.6X speedup over CPU code.</em>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/07/orb_lena_arrayfire.png\"><img class=\"alignnone size-full wp-image-6194\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/07/orb_lena_arrayfire.png\" alt=\"ArrayFire ORB\" width=\"1024\" height=\"512\" /></a></p>\r\n<p style=\"text-align: center;\"><em>ORB with OpenCV for CUDA, 16.4X speedup over CPU code.</em>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/07/orb_lena_opencv.png\"><img class=\"alignnone size-full wp-image-6195\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/07/orb_lena_opencv.png\" alt=\"OpenCV ORB\" width=\"1024\" height=\"512\" /></a></p>\r\n\r\n<h3>Discussion</h3>\r\nWe see that there is a clear advantage using GPUs over CPUs when it comes to processing time, as stated before in Part 1. By using GPUs, it is possible to do descriptor extraction more than <strong>20 times</strong> faster than with a CPU. Similarly, we can achieve average speedup of about <strong>25 times</strong> for descriptor matching using hamming distance.\r\n\r\nThese are preliminary values. This function is still under development. Please inquire with technical@arrayfire.com if you are interested in trying out our upcoming Computer Vision functions in ArrayFire.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. “Machine learning for high-speed corner detection.” Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. “ORB: an efficient alternative to SIFT or SURF.” Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] http://docs.opencv.org/trunk/doc/py_tutorials/py_feature2d/py_orb/py_orb.html','Computer Vision in ArrayFire - Part 2: Feature Description and Matching','','publish','open','open','','computer-vision-in-arrayfire-part-2','','\nhttp://sandbox.arrayfire.com/computer-vision-arrayfire-part-1/','2014-07-29 17:05:48','2014-07-29 17:05:48','',0,'http://sandbox.arrayfire.com/?p=5885',0,'post','',2),(5886,17795,'2014-06-18 03:20:08','2014-06-18 03:20:08','','ArrayFire Harris','','inherit','open','open','','harris_arrayfire','','','2014-06-18 03:20:08','2014-06-18 03:20:08','',5857,'http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png',0,'attachment','image/png',0),(5887,17795,'2014-06-18 03:20:13','2014-06-18 03:20:13','','OpenCV Harris','','inherit','open','open','','harris_opencv','','','2014-06-18 03:20:13','2014-06-18 03:20:13','',5857,'http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png',0,'attachment','image/png',0),(5888,17795,'2014-06-18 03:20:18','2014-06-18 03:20:18','','ArrayFire FAST','','inherit','open','open','','fast_arrayfire','','','2014-06-18 03:20:18','2014-06-18 03:20:18','',5857,'http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png',0,'attachment','image/png',0),(5889,17795,'2014-06-18 03:20:23','2014-06-18 03:20:23','','OpenCV FAST','','inherit','open','open','','fast_opencv','','','2014-06-18 03:20:23','2014-06-18 03:20:23','',5857,'http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png',0,'attachment','image/png',0),(5890,17795,'2014-06-18 03:21:38','2014-06-18 03:21:38','Different from FAST, the ORB descriptor extractor scales according to the number of pixels of the input image, even though it relies on FAST to detect features.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=303245979\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nFinally, the Hamming matcher benchmarks are below. To perform this measurements, we used a set of 500 descriptors as the test descriptors (e.g., number of descriptors extracted from an image), being matched to a database containing 500 to 5 million descriptors, separated by a factor of 10.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1730737789\" seamless frameborder=0 scrolling=no></iframe>','Computer Vision in ArrayFire - Part 2: Feature Description','','inherit','open','open','','5885-revision-v1','','','2014-06-18 03:21:38','2014-06-18 03:21:38','',5885,'http://sandbox.arrayfire.com/5885-revision-v1/',0,'revision','',0),(5891,17795,'2014-06-18 03:22:51','2014-06-18 03:22:51','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\n\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<h3>Feature Detection Samples</h3>\r\n\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples \r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/12/harris_arrayfire.png\"><img class=\"alignnone size-full wp-image-5710\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/12/harris_lena.png\" alt=\"Harris Corners - ArrayFire\" width=\"1024\" height=\"600\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/12/harris_opencv.png\"><img class=\"alignnone size-full wp-image-5710\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/12/harris_lena.png\" alt=\"Harris Corners - OpenCV\" width=\"1024\" height=\"600\" /></a>\r\n\r\n<h3>Discussion</h3>\r\n\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n\r\n<h3>References</h3>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:22:51','2014-06-18 03:22:51','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5892,17795,'2014-06-18 03:24:02','2014-06-18 03:24:02','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\n\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe height=371 width=600 src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" seamless frameborder=0 scrolling=no></iframe>\r\n\r\n<h3>Feature Detection Samples</h3>\r\n\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples \r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" class=\"alignnone size-full wp-image-5886\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" class=\"alignnone size-full wp-image-5887\" /></a>\r\n\r\n<h3>Discussion</h3>\r\n\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n\r\n<h3>References</h3>\r\n\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:24:02','2014-06-18 03:24:02','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5893,17795,'2014-06-18 03:26:23','2014-06-18 03:26:23','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Feature Detection Samples</h3>\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-medium\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire-300x300.png\" alt=\"ArrayFire Harris\" width=\"300\" height=\"300\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-medium\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv-300x300.png\" alt=\"OpenCV Harris\" width=\"300\" height=\"300\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:26:23','2014-06-18 03:26:23','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5894,17795,'2014-06-18 03:26:42','2014-06-18 03:26:42','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Feature Detection Samples</h3>\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-medium\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire-300x300.png\" alt=\"ArrayFire Harris\" width=\"300\" height=\"300\" /></a><a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-medium\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv-300x300.png\" alt=\"OpenCV Harris\" width=\"300\" height=\"300\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:26:42','2014-06-18 03:26:42','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5895,17795,'2014-06-18 03:27:12','2014-06-18 03:27:12','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Feature Detection Samples</h3>\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a><a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:27:12','2014-06-18 03:27:12','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5896,17795,'2014-06-18 03:29:38','2014-06-18 03:29:38','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Feature Detection Samples</h3>\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe similarities of FAST implementations, first with ArrayFire followed by OpenCV, are shown below.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:29:38','2014-06-18 03:29:38','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5897,17795,'2014-06-18 03:31:55','2014-06-18 03:31:55','A few weeks ago we posted <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>, talking a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire, which will be out in just a few months.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even knowing we can fully write it using core ArrayFire functions, this implementation will be more straightforward and simpler to use, combined with a better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for this new set of features. We compare the results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an Intel Sandy Bridge 32 core processor and an NVIDIA Tesla K20C GPU. Software used is ArrayFire development version and OpenCV 2.4.9 with SSE and CUDA support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. Its graph is shown below, because OpenCV\'s CUDA implementation fails with larger images we chose not to include it. Note that the horizontal axes of all graphs are in logarithmic scale.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe Harris detector scales with the number of pixels of an image, this is due to the score calculation being done before the elimination. However, FAST is a different situation, its score is only computed after elimination, only if a feature is indeed detected. Its graph, in accordance to the number of features can be seen below.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n<h3>Feature Detection Samples</h3>\r\nHere we show the detected features for both Harris and FAST, comparing ArrayFire implementation to OpenCV\'s. Numerous are the variables that influence the results, including rounding, empirically defined constants, and so on, because of this, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they are very similar, being difficult even to identify such differences (except for the colors different colors in matching features). Below we include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe similarities of FAST implementations, first with ArrayFire followed by OpenCV, are shown below.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least faster, but this is not the case for all samples. However, this is not yet the final version, we still have a lot of work to improve performance even more and to have everything working perfectly, with the same quality we always provide in each and every release. With this in mind, we can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 03:31:55','2014-06-18 03:31:55','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5898,17728,'2014-06-18 05:05:05','2014-06-18 05:05:05','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\n\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\n\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\n\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\n\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\n<h3>Feature Detection Benchmarks</h3>\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \n\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\n\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\n\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\n<h3>Feature Detection Samples</h3>\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other. Even though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\n\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\n\n&nbsp;\n\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\n\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\n\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\n\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\n<h3>Discussion</h3>\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear. For the Harris detector, ArrayFire is at least <strong>16 times faster</strong> than the CPU implementation. For the FAST feature detector, ArrayFire is <strong>3-5 times faster</strong> for a smaller number of features, but is <strong>8-10 times faster</strong> when the number of features requested is h  \n\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\n\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\n\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\n\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\n\nStay tuned for the upcoming news on our new set of computer vision functions.\n<h3>References</h3>\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-autosave-v1','','','2014-06-18 05:05:05','2014-06-18 05:05:05','',5857,'http://sandbox.arrayfire.com/5857-autosave-v1/',0,'revision','',0),(5899,17728,'2014-06-18 04:14:17','2014-06-18 04:14:17','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris Corner</strong> Detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is 4 times faster than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to 3 times faster than OpenCV\'s CUDA implementation. ArrayFire is consistently at least 2 times faster and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new computer vision set of tools.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:14:17','2014-06-18 04:14:17','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5900,17728,'2014-06-18 04:15:55','2014-06-18 04:15:55','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris Corner</strong> Detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is 4 times faster than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to 3 times faster than OpenCV\'s CUDA implementation. ArrayFire is consistently at least 2 times faster and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:15:55','2014-06-18 04:15:55','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5901,17728,'2014-06-18 04:16:43','2014-06-18 04:16:43','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is 4 times faster than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to 3 times faster than OpenCV\'s CUDA implementation. ArrayFire is consistently at least 2 times faster and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:16:43','2014-06-18 04:16:43','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5902,17728,'2014-06-18 04:17:59','2014-06-18 04:17:59','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than 10 times for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is 4 times faster than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to 3 times faster than OpenCV\'s CUDA implementation. ArrayFire is consistently at least 2 times faster and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:17:59','2014-06-18 04:17:59','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5903,17728,'2014-06-18 04:18:58','2014-06-18 04:18:58','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately follow by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:18:58','2014-06-18 04:18:58','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5904,17728,'2014-06-18 04:19:20','2014-06-18 04:19:20','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sies before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:19:20','2014-06-18 04:19:20','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5905,17728,'2014-06-18 04:20:30','2014-06-18 04:20:30','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations. \r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected. \r\n\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar. \r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance even more. We can assure that these numbers will improve even more until these algorithm are made public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:20:30','2014-06-18 04:20:30','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5906,17728,'2014-06-18 04:22:29','2014-06-18 04:22:29','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are working to improve performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:22:29','2014-06-18 04:22:29','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5907,17728,'2014-06-18 04:23:06','2014-06-18 04:23:06','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working to improve performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:23:06','2014-06-18 04:23:06','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5908,17728,'2014-06-18 04:23:48','2014-06-18 04:23:48','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:23:48','2014-06-18 04:23:48','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5909,17728,'2014-06-18 04:44:20','2014-06-18 04:44:20','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire\'s and OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire\'s CUDA implementation as well as OpenCV\'s CUDA implementation over OpenCV\'s CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:44:20','2014-06-18 04:44:20','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5910,17728,'2014-06-18 04:45:21','2014-06-18 04:45:21','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. The following graph depicts the speedup of ArrayFire CUDA and OpenCV CUDA implementation over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe following graph depicts the speedup of ArrayFire CUDA implementation as well as OpenCV CUDA implementation over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:45:21','2014-06-18 04:45:21','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5911,17728,'2014-06-18 04:46:51','2014-06-18 04:46:51','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:46:51','2014-06-18 04:46:51','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5912,17728,'2014-06-18 04:47:58','2014-06-18 04:47:58','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In the post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:47:58','2014-06-18 04:47:58','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5913,17728,'2014-06-18 04:48:31','2014-06-18 04:48:31','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation straightforward, simpler to use, and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:48:31','2014-06-18 04:48:31','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5914,17728,'2014-06-18 04:49:55','2014-06-18 04:49:55','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare our results of each of these functions to the OpenCV implementations, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:49:55','2014-06-18 04:49:55','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5915,17728,'2014-06-18 04:51:13','2014-06-18 04:51:13','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementations against OpenCV, which are currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:51:13','2014-06-18 04:51:13','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5916,17728,'2014-06-18 04:51:38','2014-06-18 04:51:38','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementations against OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:51:38','2014-06-18 04:51:38','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5917,17728,'2014-06-18 04:51:59','2014-06-18 04:51:59','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:51:59','2014-06-18 04:51:59','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5918,17728,'2014-06-18 04:53:03','2014-06-18 04:53:03','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:53:03','2014-06-18 04:53:03','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5919,17728,'2014-06-18 04:55:36','2014-06-18 04:55:36','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used is <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:55:36','2014-06-18 04:55:36','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5920,17728,'2014-06-18 04:56:45','2014-06-18 04:56:45','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:56:45','2014-06-18 04:56:45','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5921,17728,'2014-06-18 04:57:42','2014-06-18 04:57:42','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other.\r\n\r\nEven though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:57:42','2014-06-18 04:57:42','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5922,17728,'2014-06-18 04:59:26','2014-06-18 04:59:26','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other. Even though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear, as we can get speedups of more than <strong>10 times</strong> for the FAST features detector.\r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 04:59:26','2014-06-18 04:59:26','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5923,17728,'2014-06-18 05:05:10','2014-06-18 05:05:10','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other. Even though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear. For the Harris detector, ArrayFire is at least <strong>16 times faster</strong> than the CPU implementation. For the FAST feature detector, ArrayFire is <strong>3-5 times faster</strong> for a smaller number of features, but is <strong>8-10 times faster</strong> when the number of features requested is higher.  \r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we make release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 05:05:10','2014-06-18 05:05:10','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5924,17728,'2014-06-18 05:06:18','2014-06-18 05:06:18','A few weeks ago we wrote <a href=\"http://sandbox.arrayfire.com/creating-a-simple-corner-detector-with-arrayfire/\">Writing a Simple Corner Detector with ArrayFire</a>. In that post, we discussed a little bit about the new features that we are working on for ArrayFire. Some of these new computer vision features will be available in the next release of ArrayFire.\r\n\r\nFor the next release, ArrayFire will have a complete set to start with feature tracking, including FAST for feature detection [1], ORB for description [2] and a Hamming distance matcher. We will also include a dedicated version of the Harris corner detector [3], even though it can be written using existing ArrayFire functions. This implementation is straightforward, easy to use and will have better performance.\r\n\r\nFor this post, we will share some of our current benchmarks for <strong>Harris</strong> corner detector and <strong>FAST</strong> feature detector. We compare the performance of our implementation of these functions against the same functions in OpenCV, which is currently one of the best code references for computer vision.\r\n\r\nThe results shown below were all generated with an <strong>Intel Sandy Bridge Xeon processor with 32 cores</strong> for OpenCV CPU implementation and an <strong>NVIDIA Tesla K20C</strong> GPU for OpenCV CUDA and ArrayFire CUDA implementations.\r\n\r\nSoftware used for benchmarking included <strong>ArrayFire development version</strong> and <strong>OpenCV 2.4.9 with SSE and CUDA</strong> support.\r\n<h3>Feature Detection Benchmarks</h3>\r\nWe first start with some benchmarks of the Harris corner detector. The run times for OpenCV\'s CUDA implementation at larger sizes are not included because it runs out of memory at larger image sizes. Note that the horizontal axes of all graphs are in logarithmic scale. \r\n\r\nThe following graphs depict the speedup of ArrayFire CUDA and OpenCV CUDA implementations over OpenCV CPU implementation.\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1713785027\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\n<iframe src=\"//docs.google.com/a/sandbox.arrayfire.com/spreadsheets/d/1OqbdY8B8K7z6_trW2qB1lseDREGzVe7V1OJKsPnmUC4/gviz/chartiframe?oid=1883059785\" width=\"600\" height=\"371\" frameborder=\"0\" scrolling=\"no\" seamless=\"\"></iframe>\r\n\r\nThe horizontal axis for Harris detector is the number of pixels, while that of FAST detector is number of features detected. This was done because the Harris score is calculated for all the pixels before eliminating the pixels whose score falls below a certain threshold. The score for FAST features are detected by progressively eliminating pixels that do not fit various criteria. The FAST scores are only calculated once the features have been detected. This results in the time taken for Harris to scale with the number of pixels, while the times taken for FAST scales with the number of features detected.\r\n<h3>Feature Detection Samples</h3>\r\nIn this section, we show the images with the detected features plotted on them for both ArrayFire and OpenCV. There are many variables that influence the results, including among others, rounding and empirically defined constants. For these reasons, we can not expect two implementations to be perfectly equal to each other. Even though ArrayFire and OpenCV implementations do not give the exact same results, they provide features that are very similar.\r\n\r\nThe following set of images include samples for the Harris corner detector with ArrayFire, immediately followed by OpenCV.\r\n\r\n&nbsp;\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\"><img class=\"alignnone wp-image-5886 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_arrayfire.png\" alt=\"ArrayFire Harris\" width=\"512\" height=\"512\" /></a>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\"><img class=\"alignnone wp-image-5887 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/harris_opencv.png\" alt=\"OpenCV Harris\" width=\"512\" height=\"512\" /></a>\r\n\r\nThe following images show the similarities in the FAST implementations, first with ArrayFire followed by OpenCV.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\"><img class=\"alignnone size-full wp-image-5888\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_arrayfire.png\" alt=\"ArrayFire FAST\" width=\"512\" height=\"512\" /></a>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\"><img class=\"alignnone size-full wp-image-5889\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/fast_opencv.png\" alt=\"OpenCV FAST\" width=\"512\" height=\"512\" /></a>\r\n<h3>Discussion</h3>\r\nBy looking at the previous graphs, the advantage of using GPUs for computer vision applications over CPUs is made very clear. For the Harris detector, ArrayFire is at least <strong>16 times faster</strong> than the CPU implementation. For the FAST feature detector, ArrayFire is <strong>3-5 times faster</strong> for a smaller number of features, but is <strong>8-10 times faster</strong> when the number of features requested is higher.  \r\n\r\nComparing OpenCV\'s CUDA implementation, we see that in almost all cases we are already at least as good as better. For Harris detector, ArrayFire is <strong>4 times faster</strong> than OpenCV\'s GPU implementation at smaller sizes before evening out. At larger sizes OpenCV CUDA implementation runs out of GPU memory and fails to detect any features.\r\n\r\nFor FAST, ArrayFire is up to <strong>3 times faster</strong> than OpenCV\'s CUDA implementation. ArrayFire is consistently at least <strong>2 times faster</strong> and is slower for only one image.\r\n\r\nHowever, this is not yet the final version, we are still working on improving performance. We can assure that these numbers will be even more impressive when we release these algorithms to the public.\r\n\r\nIf you can not wait until the release and want to get a taste of what is coming, please, contact us at <a href=\"mailto:sales@arrayfire.com\">sales@arrayfire.com</a>, we will be happy to discuss on how you can get the latest features of ArrayFire before the release!\r\n\r\nStay tuned for the upcoming news on our new set of computer vision functions.\r\n<h3>References</h3>\r\n[1] Rosten, Edward, and Tom Drummond. \"Machine learning for high-speed corner detection.\" Computer Vision–ECCV 2006. Springer Berlin Heidelberg, 2006. 430-443.\r\n[2] Rublee, Ethan, et al. \"ORB: an efficient alternative to SIFT or SURF.\" Computer Vision (ICCV), 2011 IEEE International Conference on. IEEE, 2011.\r\n[3] Harris, Chris, and Mike Stephens. \"A combined corner and edge detector.\" Alvey vision conference. Vol. 15. 1988.','Computer Vision in ArrayFire - Part 1: Feature Detection','','inherit','open','open','','5857-revision-v1','','','2014-06-18 05:06:18','2014-06-18 05:06:18','',5857,'http://sandbox.arrayfire.com/5857-revision-v1/',0,'revision','',0),(5931,7,'2014-06-19 20:03:02','2014-06-19 20:03:02','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fourth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lvvyk\" size=\"regular\" ]Windows, v3.6.1\r\n(64-bit)[/button][/column][column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lw515\" size=\"regular\" ]Linux, v3.6.1\r\n(64-bit)[/button][/column][column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.6.1\r\n(64-bit)[/button][/column][column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2017-09-19/5dgdc4\" size=\"regular\" ]Tegra X1 v3.5.1\r\n(64-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"https://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"https://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"https://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"https://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"https://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"https://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','publish','closed','closed','','download','','','2018-07-06 00:14:54','2018-07-06 04:14:54','',0,'http://sandbox.arrayfire.com/?page_id=5931',0,'page','',0),(5932,7,'2014-06-19 19:04:15','2014-06-19 19:04:15','Links go here.','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:04:15','2014-06-19 19:04:15','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5934,7,'2014-06-19 19:16:12','2014-06-19 19:16:12','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"two-fifths\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Download ArrayFire[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button]\r\n\r\n[/column][column type=\"three-fifths\" last=\"true\"][gap size=\"7%\"]\r\n<div id=\"wistia_rj2bar3xxp\" class=\"wistia_embed\"></div>\r\n[/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:16:12','2014-06-19 19:16:12','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5935,7,'2014-06-19 19:19:04','2014-06-19 19:19:04','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"two-fifths\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button]\r\n\r\n[/column][column type=\"three-fifths\" last=\"true\"][gap size=\"7%\"]\r\n<div id=\"wistia_rj2bar3xxp\" class=\"wistia_embed\"></div>\r\n[/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:19:04','2014-06-19 19:19:04','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5936,7,'2014-06-19 19:21:10','2014-06-19 19:21:10','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-third\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:21:10','2014-06-19 19:21:10','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5937,7,'2014-06-19 19:21:37','2014-06-19 19:21:37','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-third\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button][/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:21:37','2014-06-19 19:21:37','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5938,7,'2014-06-19 19:22:31','2014-06-19 19:22:31','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-third\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:22:31','2014-06-19 19:22:31','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5939,7,'2014-06-19 19:23:21','2014-06-19 19:23:21','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:23:21','2014-06-19 19:23:21','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5940,7,'2014-06-19 19:24:27','2014-06-19 19:24:27','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:24:27','2014-06-19 19:24:27','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5941,7,'2014-06-19 19:26:10','2014-06-19 19:26:10','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"7%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:26:10','2014-06-19 19:26:10','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5942,7,'2014-06-19 19:26:52','2014-06-19 19:26:52','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:26:52','2014-06-19 19:26:52','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5943,7,'2014-06-19 19:27:11','2014-06-19 19:27:11','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1[/button][/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n<div></div>\r\n<div>[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:27:11','2014-06-19 19:27:11','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5944,7,'2014-06-19 19:29:39','2014-06-19 19:29:39','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n<div></div>\r\n<div>[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:29:39','2014-06-19 19:29:39','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5945,7,'2014-06-19 19:32:06','2014-06-19 19:32:06','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\n[column type=\"one-fifth\"][/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Old installers[/button][/column]\r\n\r\n[column type=\"one-fifth\"][/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Documentation[/button][/column]\r\n\r\n[column type=\"one-fifth\"][/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n<div></div>\r\n<div>[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:32:06','2014-06-19 19:32:06','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5946,7,'2014-06-19 19:32:19','2014-06-19 19:32:19','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Old installers[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Documentation[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n<div id=\"arrayfire\">Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.</div>\r\n<div></div>\r\n<div>[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:32:19','2014-06-19 19:32:19','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5947,7,'2014-06-19 19:32:41','2014-06-19 19:32:41','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Old installers[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n\r\n[column type=\"one-fifth\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Documentation[/button][/column]\r\n\r\n[column type=\"one-fifth\"].[/column]\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:32:41','2014-06-19 19:32:41','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5948,7,'2014-06-19 19:38:17','2014-06-19 19:38:17','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Make your choice, adventurous stranger.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:38:17','2014-06-19 19:38:17','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5949,7,'2014-06-19 19:39:39','2014-06-19 19:39:39','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]This is where you download ArrayFire.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:39:39','2014-06-19 19:39:39','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5950,7,'2014-06-19 19:40:22','2014-06-19 19:40:22','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Pick an ArrayFire, any ArrayFire.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:40:22','2014-06-19 19:40:22','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5951,7,'2014-06-19 19:41:42','2014-06-19 19:41:42','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Pick an operating system, anyoperating system.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:41:42','2014-06-19 19:41:42','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5952,7,'2014-06-19 19:42:32','2014-06-19 19:42:32','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Kick the tires and light the fires.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:42:32','2014-06-19 19:42:32','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5953,7,'2014-06-19 19:42:50','2014-06-19 19:42:50','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Download ArrayFire. [/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:42:50','2014-06-19 19:42:50','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5954,7,'2014-06-19 19:43:26','2014-06-19 19:43:26','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Pick your OS. Download ArrayFire. [/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:43:26','2014-06-19 19:43:26','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5955,7,'2014-06-19 19:44:51','2014-06-19 19:44:51','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Select your OS.[/custom_headline]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Download ArrayFire. [/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:44:51','2014-06-19 19:44:51','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5956,7,'2014-06-19 19:45:53','2014-06-19 19:45:53','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]The is the part when you download ArrayFire.[/custom_headline]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:45:53','2014-06-19 19:45:53','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5957,7,'2014-06-19 19:46:53','2014-06-19 19:46:53','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]The is the part when you download ArrayFire.[/custom_headline][gap size=\"5%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:46:53','2014-06-19 19:46:53','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5958,7,'2014-06-19 19:47:02','2014-06-19 19:47:02','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"15%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:47:02','2014-06-19 19:47:02','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5959,7,'2014-06-19 19:47:18','2014-06-19 19:47:18','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"10%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:47:18','2014-06-19 19:47:18','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5960,7,'2014-06-19 19:47:34','2014-06-19 19:47:34','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n<div id=\"arrayfire\">[gap size=\"10%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:47:34','2014-06-19 19:47:34','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5961,7,'2014-06-19 19:49:12','2014-06-19 19:49:12','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n\r\nLooking for an old installer? Try here.\r\n<div id=\"arrayfire\">[gap size=\"10%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:49:12','2014-06-19 19:49:12','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5962,7,'2014-06-19 19:49:50','2014-06-19 19:49:50','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n<div id=\"arrayfire\">[gap size=\"10%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:49:50','2014-06-19 19:49:50','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5963,7,'2014-06-19 19:51:10','2014-06-19 19:51:10','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our documentation![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"10%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:51:10','2014-06-19 19:51:10','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5964,7,'2014-06-19 19:51:24','2014-06-19 19:51:24','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our documentation![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"5%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:51:24','2014-06-19 19:51:24','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5965,7,'2014-06-19 19:51:36','2014-06-19 19:51:36','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our documentation![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:51:36','2014-06-19 19:51:36','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5966,7,'2014-06-19 19:52:54','2014-06-19 19:52:54','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. The is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <a href=\"http://www.sandbox.arrayfire.com/docs/\">documentation</a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:52:54','2014-06-19 19:52:54','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5967,7,'2014-06-19 19:53:29','2014-06-19 19:53:29','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/docs/installation.htm\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? Try here.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <a href=\"http://www.sandbox.arrayfire.com/docs/\">documentation</a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 19:53:29','2014-06-19 19:53:29','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5968,7,'2014-06-19 20:01:22','2014-06-19 20:01:22','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-win-2.1.exe\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-linux-2.1.run\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-maci-2.1.zip\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <a href=\"http://www.sandbox.arrayfire.com/docs/\">documentation</a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download Page','','inherit','open','open','','5931-revision-v1','','','2014-06-19 20:01:22','2014-06-19 20:01:22','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5970,7,'2014-06-19 20:06:38','2014-06-19 20:06:38','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-win-2.1.exe\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-linux-2.1.run\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-maci-2.1.zip\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <a href=\"http://www.sandbox.arrayfire.com/docs/\">documentation</a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download','','inherit','open','open','','5931-revision-v1','','','2014-06-19 20:06:38','2014-06-19 20:06:38','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5972,7,'2014-06-19 20:25:13','2014-06-19 20:25:13','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-win-2.1.exe\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-linux-2.1.run\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/2.1/ArrayFire-maci-2.1.zip\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download','','inherit','open','open','','5931-revision-v1','','','2014-06-19 20:25:13','2014-06-19 20:25:13','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5975,7,'2014-06-20 14:36:17','2014-06-20 14:36:17','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','ArrayFire Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 14:36:17','2014-06-20 14:36:17','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5977,17728,'2014-06-20 17:11:09','2014-06-20 17:11:09','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 17:11:09','2014-06-20 17:11:09','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5979,17794,'2014-06-25 23:09:40','2014-06-25 23:09:40','ArrayFire is a fantastic library when it comes to performance. One of the things that people overlook when looking into ArrayFire is it\'s powerful indexing capabilities.\r\n\r\nThe main data structure in the ArrayFire library is the <a href=\"http://www.sandbox.arrayfire.com/docs/classaf_1_1array.htm\" title=\"array\" target=\"_blank\">array</a>. The array stores the data in a column major order. This means that the following code:\r\n\r\n<pre>\r\nfloat a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};\r\narray A(3, 3, a);\r\n</pre>\r\n\r\nWill produce the following matrix:\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.png\" alt=\"3x3 Column Major Matrix\" width=\"114\" height=\"67\" class=\"alignnone size-full wp-image-5994\" /></a>\r\n\r\nNotice how the first three values of the <code>a</code> array make up the first column of <code>A</code>.\r\n\r\nWhen you want to perform an operation on every element of the array you can just use the variable name with the operation. The following command adds 5 to each element of the array:\r\n\r\n<pre>\r\nA += 5;\r\n</pre>\r\n\r\nIf you want to assign one value to each element of the array, you will be tempted to do something like this:\r\n\r\n<pre>\r\nA = 3; // Don\'t do this\r\n</pre>\r\n\r\nThis operation will actually create an array with a single element with the value of 3. In order to perform this operation you will need to use the use the <code>constant</code> function or the span object(more on this later).\r\n\r\n<pre>\r\nA = constant(3, A.dims()); // Okay\r\nA(span) = 3;               // Also works\r\n</pre>\r\n\r\n\r\nSometimes you only want to perform a calculation on a part of the data. In this case you can index into the elements of the matrix using the parenthesis notation. For example, you can access the middle element of the initial array by using:\r\n\r\n<pre>\r\nfloat a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};\r\narray A(3, 3, a);\r\narray B = A(1, 1);\r\n// B == 5\r\n</pre>\r\n\r\nThe first number in the parenthesis is the column index, and the second number is the row index. You can index in this way to up to 4 dimensions.\r\n\r\nArrayFire also comes with a host of helper functions which allow you to access whole rows and columns of a matrix. The <code>row</code> and <code>col</code> functions will return an array which is made up of elements in the row an column respectively. You can access a set of rows and columns using the <code>rows</code> and <code>cols</code> functions.\r\n\r\n<pre>\r\nfloat a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};\r\narray A(3, 3, a);\r\narray B = A.row(2);\r\narray C = A.cols(1,2);\r\n</pre>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-3.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-3-300x61.png\" alt=\"A.row(2); A.cols(1,2);\" width=\"300\" height=\"61\" class=\"alignnone size-medium wp-image-5995\" /></a>\r\n\r\nYou can also use parenthesis notation to extract rows and columns of a matrix or volume. In order to do this, we will use the <code>span</code> and <code>seq</code> objects to specify which rows and columns we need.\r\n\r\nThe <code>seq</code> object returns a sequence of values. For example, you can create a sequence of <code>{0, 1, 2, 3}</code> by calling <code>seq(4)</code>. The <code>span</code> object is a sequence which gives all the elements of an array. Using these objects you can do some pretty sophisticated indexing. The previous example can be rewritten as the following:\r\n\r\n<pre>\r\nfloat[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9};\r\narray A(3, 3, a);\r\narray B = A(2, span);\r\narray C = A(span, seq(1,2));\r\n</pre>\r\n\r\nThe values of B and C should be identical to the first example.\r\n\r\nYou can even index into an array using another array object. The values of the array object passed into the parenthesis will be used as indices. Here is an example:\r\n\r\n<pre>\r\nfloat a[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};\r\nfloat idx[] = {1, 3, 5};\r\narray A(9, a);\r\narray IDX(3, idx);\r\narray B = A(IDX); //B == {8, 6, 4}\r\n</pre>\r\n\r\nWe first create two C-style arrays. The first array contains the values from 9 to 1 and the second array contains the indices we want to access. We create array objects from these values and pass the <code>IDX</code> as the index of array <code>A</code>. The resulting array B will contain the values <code>{8, 6, 4}</code> which corresponds to the indices <code>{1, 3, 5}</code>.\r\n\r\nIf the passed array object is a b8(boolean) type, then only the non-zero values will be returned.\r\n\r\n<pre>\r\nfloat a[] =  {9, 8, 7, 6, 5, 4, 3, 2, 1};\r\nbool  even[] =   {0, 1, 0, 1, 0, 1, 0, 1, 0};\r\narray A(9, a);\r\narray EVEN(9, even);\r\narray B = A(EVEN);\r\n</pre>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-4.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-4.png\" alt=\"Boolean Indexing\" width=\"260\" height=\"198\" class=\"size-full wp-image-6016\" /></a>\r\n\r\nThis technique allows you to input relation operators as indexes. For example, we can extract all values which are greater than 5 using the following code:\r\n\r\n<pre>\r\nfloat a[] =  {9, 8, 7, 6, 5, 4, 3, 2, 1};\r\narray A(9, a);\r\narray B = A(A > 5);\r\n</pre>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-5.png\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn-5.png\" alt=\"Relational Operator Indexing\" width=\"141\" height=\"198\" class=\"alignnone size-full wp-image-6017\" /></a>\r\n\r\nI hope this blog was helpful for anyone who is interested in what ArrayFire has to offer. This is the first part of the indexing series. In a future post I will talk about more advanced topics including performance and memory accesses.','Indexing with ArrayFire','','publish','open','open','','indexing-with-arrayfire','','','2014-06-27 16:22:15','2014-06-27 16:22:15','',0,'http://sandbox.arrayfire.com/?p=5979',0,'post','',0),(5981,7,'2014-06-20 17:52:49','2014-06-20 17:52:49','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n\r\nLooking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 17:52:49','2014-06-20 17:52:49','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5982,7,'2014-06-20 17:53:39','2014-06-20 17:53:39','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"]\r\n\r\n[column type=\"one-third\"]\r\n\r\n[gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column]\r\n\r\n[column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column]\r\n\r\nLooking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise.\r\n\r\n[custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 17:53:39','2014-06-20 17:53:39','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5983,7,'2014-06-20 18:04:50','2014-06-20 18:04:50','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"] [custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"] [column type=\"one-third\"] [gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button] [gap size=\"10%\"] [/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column] [column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column] Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>. Each download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. [custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 18:04:50','2014-06-20 18:04:50','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5984,7,'2014-06-20 18:06:06','2014-06-20 18:06:06','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"] [custom_headline type=\"center\" level=\"h3\"]Thanks. This is the part when you download ArrayFire.[/custom_headline][gap size=\"3%\"] [column type=\"one-third\"] [gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznk\" size=\"x-large\" block=\"true\"]Windows, v2.1 (64-bit)[/button] [gap size=\"10%\"] [/column][column type=\"one-third\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznt\" size=\"x-large\" ]Linux, v2.1 (32 &amp; 64-bit)[/button][/column] [column type=\"one-third\" last=\"true\"][gap size=\"15%\"][button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-22/cznw\" size=\"x-large\" ]Mac OSX, v2.1 (64-bit)[/button][/column] Looking for an old installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.\r\n\r\nEach download contains both CUDA and OpenCL files. Your license file will determine your features, e.g. Free, Developer, Pro, or Enterprise. [custom_headline type=\"center\" level=\"h3\"]Awesome. Don\'t forget to check out our <span style=\"color: #ff6600;\"><a href=\"http://www.sandbox.arrayfire.com/docs/\"><span style=\"color: #ff6600;\">documentation</span></a></span> and <a href=\"http://forums.accelereyes.com/\"><span style=\"color: #ff6600;\">forums</span></a>![/custom_headline]\r\n<div id=\"arrayfire\">[gap size=\"3%\"]</div>\r\n[/content_band]','Download','','inherit','open','open','','5931-revision-v1','','','2014-06-20 18:06:06','2014-06-20 18:06:06','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(5985,7,'2014-06-20 18:30:38','2014-06-20 18:30:38','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"two-fifths\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"15%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/download\" size=\"x-large\" block=\"true\"]Download ArrayFire[/button]\r\n\r\n[gap size=\"10%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://www.meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button]\r\n\r\n[/column][column type=\"three-fifths\" last=\"true\"][gap size=\"7%\"]\r\n<div id=\"wistia_rj2bar3xxp\" class=\"wistia_embed\" style=\"width: 640px; height: 388px;\"></div>\r\n<script src=\"//fast.wistia.com/assets/external/E-v1.js\" charset=\"ISO-8859-1\"></script><script>// <![CDATA[\r\nwistiaEmbed = Wistia.embed(\"rj2bar3xxp\");\r\n// ]]></script>[/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\"]Faster code[/custom_headline]\r\n\r\nArrayFire is a fast, hardware-neutral software library for GPU computing with an easy-to-use API. Its array-based function set makes GPU programming simple. A few lines of code in ArrayFire can replace dozens of lines of raw GPU code, saving you valuable time and lowering development costs.\r\n\r\n[gap size=\"10%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/download\" size=\"x-large\" ]Download ArrayFire[/button][/column][column type=\"one-half\" last=\"true\" class=\"center-text\"][gap size=\"5%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/Triumvirate_Exported.png\"][/column] [gap size=\"5%\"]\r\n\r\n[column type=\"one-third\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/04/Googlelogo-e1396387097279.png\"][line]Video content analysis is the basis for categorizing videos and enabling search by content. Google used ArrayFire to extract motion features in video, improving performance by substantially accelerating the solution of the L1-regularized least-squares optimization problem.[/column][column type=\"one-third\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/04/Koch-Industries-e1396387359637.jpg\"][line]Andrew Shin, Market Risk Manager of Koch Supply &amp; Trading, achieves significant performance increases on option pricing algorithms using ArrayFire software, \"My buddy and I are, at best, novice programmers and we couldn\'t imagine having to figure out how to code all this in CUDA.\"[/column][column type=\"one-third\" last=\"true\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/04/nasa-e1396387230473.png\"][line]The main thrust of this research was improving Mars rover image compression via GPUs and genetic algorithms. With ArrayFire software and GPUs, the researchers were able to achieve 5X speedups on the larger data sizes.[/column]\r\n<div id=\"hardware\"></div>\r\n[/content_band]\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[column type=\"one-half\"][gap size=\"15%\"]\r\n\r\n<img class=\"aligncenter\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/CUDA-logo.jpg\" alt=\"CUDA logo\" width=\"231\" height=\"140\" />\r\n\r\n<img class=\"aligncenter\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/OpenCLLogo_678x452.png\" alt=\"OpenCL\" width=\"326\" height=\"217\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"][gap size=\"10%\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"] ArrayFire for CUDA and OpenCL[/custom_headline]\r\n\r\nArrayFire supports CUDA-capable NVIDIA GPUs and most OpenCL devices, including AMD GPUs/APUs and Intel Xeon Phi co-processors. It also supports mobile OpenCL devices from ARM, Qualcomm, and others.\r\n\r\nArrayFire is a high-performance software library designed for maximum productivity and speed without the hassle of writing difficult low-level device code. Each of ArrayFire\'s functions has been hand-tuned by our CUDA and OpenCL experts.\r\n\r\n[/column]\r\n<div id=\"mobile\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\"  ]Mobile GPU Computing[/custom_headline]\r\n\r\nMobile GPUs offer accelerated performance. If you would like to use ArrayFire in a mobile application or if you would like to hire our mobile acceleration services, email us at <a href=\"mailto:sales@arrayfire.com\" target=\"_blank\">sales@arrayfire.com</a> and include a description of your application.\r\n\r\nOur clients have achieved between 5X to 30X speed boosts for convolutions and other compute functions on mobile devices. It enables:[icon_list][icon_list_item type=\"angle-double-right\"]Real-time video processing[/icon_list_item][icon_list_item type=\"angle-double-right\"]Better augmented reality [/icon_list_item][icon_list_item type=\"angle-double-right\"]Better computational photograph[/icon_list_item][icon_list_item type=\"angle-double-right\"]Faster data processing[/icon_list_item][/icon_list]\r\n\r\nAll mobile devices have a GPU which can deliver greater compute throughput than the CPU. Why not use the GPU to make your app faster?[/column][column type=\"one-half\" fade=\"true\" last=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"10%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\"][/column]\r\n<div id=\"documentation\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\"]Documentation[/custom_headline]\r\n<h5>ArrayFire for C, C++, and Fortran</h5>\r\nOpen the hood—take a look at the beautiful nitty-gritty.\r\n\r\n[icon type=\"angle-double-right\"] <a href=\"http://www.sandbox.arrayfire.com/docs/\" target=\"_blank\">CUDA &amp; OpenCL C/C++</a>\r\n<h5>Functions</h5>\r\nHundreds of functions, hand-tuned and optimized by our engineers.\r\n\r\n[icon type=\"angle-double-right\"] <a title=\"ArrayFire Functions\" href=\"http://www.sandbox.arrayfire.com/docs/modules.htm\">ArrayFire Functions</a>\r\n<h5>User Forums</h5>\r\nEvery post gets a response from ArrayFire engineers.\r\n\r\n[icon type=\"angle-double-right\"] <a href=\"http://forums.accelereyes.com/\" target=\"_blank\">User Forums</a>\r\n\r\n[/column][column class=\"center-text\" type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" ][gap size=\"5%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1.png\"][/column]\r\n<div id=\"benchmarks\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n[column type=\"one-half\" fade=\"true\" fade_animation=\"in-from-left\" ][gap size=\"5%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Benchmark-guy-torso-opposite-e1392155948298.png\"][/column]\r\n\r\n[column type=\"one-half\" last=\"true\"][custom_headline type=\"left\" level=\"h3\" ]Benchmarks[/custom_headline]\r\n\r\nAll benchmarks were performed on a NVIDIA Tesla C2050 with an Intel i7-950 processor. The benchmarks compare ArrayFire with several popular CPU-based acceleration libraries, including <a href=\"http://software.intel.com/en-us/articles/intel-mkl/\" target=\"_new\">Intel Math Kernel Library</a>, <a href=\"http://software.intel.com/en-us/articles/intel-ipp/\" target=\"_new\">Intel Integrated Performance Primitives</a>, <a href=\"http://eigen.tuxfamily.org/index.php?title=Main_Page\" target=\"_new\">Eigen</a>, and <a href=\"http://arma.sourceforge.net/\" target=\"_new\">Armadillo</a>.[/column]\r\n\r\n[column type=\"one-fifth\"].[/column][column type=\"three-fifths\"][tab_nav type=\"four-up\"][tab_nav_item title=\"Base\" active=\"true\"][tab_nav_item title=\"Linear Algebra\" active=\"\"][tab_nav_item title=\"Convolution\" active=\"\"][tab_nav_item title=\"Utility\" active=\"\"][/tab_nav][tabs][tab active=\"true\"]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_multiply-1024x730.png\" alt=\"Matrix Multiply\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_transpose-1024x730.png\" alt=\"Matrix Transpose\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/fft-1024x730.png\" alt=\"FFT\" width=\"491\" height=\"350\" />[/tab][tab]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/lu-1024x730.png\" alt=\"LU\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/svd-1024x730.png\" alt=\"SVD\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/solve-1024x730.png\" alt=\"Solve\" width=\"491\" height=\"350\" />[/tab][tab]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/convs-1024x730.png\" alt=\"Convs\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/conv-1024x730.png\" alt=\"Conv\" width=\"491\" height=\"350\" />[/tab][tab]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sum-1024x730.png\" alt=\"sum\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sort-1024x730.png\" alt=\"sort\" width=\"491\" height=\"350\" />[line]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/scan-1024x730.png\" alt=\"scan\" width=\"491\" height=\"350\" />[/tab][/tabs][/column][column type=\"one-fifth\" last=\"true\"].[/column]\r\n<div id=\"free\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"].[/column][column type=\"one-fourth\"].[custom_headline type=\"center\"  level=\"h3\" class=\"mtn\"]ArrayFire Free[/custom_headline][/column][column type=\"one-fourth\" last=\"true\"].[/column][column type=\"one-fourth\"  fade=\"true\" fade_animation=\"in-from-left\" ][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/right-leaning-e1391788779101.png\"][/column][column type=\"one-fourth\"]\r\n<table>\r\n<tbody>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Functions[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Basic Operations</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Arithmetic</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Signal Processing</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Image Processing</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Statistics</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Visualization</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n[gap size=\"17%\"][button type=\"flat\" block=\"true\" shape=\"rounded\" size=\"large\"  href=\"http://sandbox.arrayfire.com/download\"]Download ArrayFire[/button] [/column][column type=\"one-fourth\"]\r\n<table>\r\n<tbody>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Hardware[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] CUDA</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] OpenCL</td>\r\n</tr>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Languages[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] C/C++</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Fortran</td>\r\n</tr>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Advanced[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td> [icon type=\"check-circle\" style=\"color: #8cc540;\"] GFOR Loop</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n[/column][column type=\"one-fourth\" last=\"true\"]\r\n<table>\r\n<tbody>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Platforms[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Windows</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Linux</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] Mac</td>\r\n</tr>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Data Types[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td>[icon type=\"check-circle\" style=\"color: #8cc540;\"] All types</td>\r\n</tr>\r\n<tr>\r\n<td>[custom_headline type=\"center\" level=\"h5\"]Support[/custom_headline]</td>\r\n</tr>\r\n<tr>\r\n<td> [icon type=\"check-circle\" style=\"color: #8cc540;\"] Forums</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\n<div id=\"licensing\"></div>\r\n[/column][gap size=\"8%\"]\r\n\r\n[pricing_table id=\"pricing\" columns=\"3\"][pricing_table_column  featured=\"false\" title=\"ArrayFire Developer\" currency=\"$\" price=\"499 / year\" interval=\"$149 / year (Academic)\"] [icon_list] [icon_list_item type=\"star\" ]Dedicated license [/icon_list_item] [icon_list_item  type=\"times-circle\"] Starts at 2 GPUs or devices [/icon_list_item] [icon_list_item type=\"times-circle\"] Linear algebra [/icon_list_item] [icon_list_item type=\"times-circle\"] Sparse matrices [/icon_list_item][icon_list_item type=\"times-circle\"] Phone support [/icon_list_item][icon_list_item type=\"times-circle\"] Premium support &amp; consulting [/icon_list_item][/icon_list] [button href=\"http://sandbox.arrayfire.com/shop\"] Purchase [/button] [/pricing_table_column] [pricing_table_column featured=\"true\" featured_sub=\"Most Popular\" title=\"ArrayFire Pro\" currency=\"$\" price=\"1,499 / year\" interval=\"$525 / year (Academic)\"] [icon_list] [icon_list_item type=\"star\"] Dedicated license [/icon_list_item] [icon_list_item type=\"star\"] Starts at 2 GPUs or devices [/icon_list_item] [icon_list_item type=\"star\"] Linear algebra [/icon_list_item][icon_list_item type=\"star\"] Sparse matrices [/icon_list_item][icon_list_item type=\"times-circle\"] Phone support [/icon_list_item][icon_list_item type=\"times-circle\"] Premium support &amp; consulting [/icon_list_item] [/icon_list] [button href=\"http://sandbox.arrayfire.com/shop\"]Purchase [/button] [/pricing_table_column] [pricing_table_column featured=\"false\" title=\"ArrayFire Enterprise\" currency=\"$\" price=\"2,999 / year\" interval=\"$1,049 / year (Academic)\"] [icon_list] [icon_list_item type=\"star\"] Dedicated license [/icon_list_item] [icon_list_item type=\"star\"] Starts at 2 GPUs or devices [/icon_list_item] [icon_list_item type=\"star\"] Linear algebra [/icon_list_item][icon_list_item type=\"star\"]Sparse matrices [/icon_list_item][icon_list_item type=\"star\"] Phone support[/icon_list_item][icon_list_item type=\"star\"]Premium support &amp; consulting [/icon_list_item][/icon_list] [button href=\"http://sandbox.arrayfire.com/shop\"] Purchase [/button] [/pricing_table_column] [/pricing_table]\r\n<div id=\"whitepapers\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"20%\"][image type=\"thumbnail\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/wp2.jpg\"][button href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-29/dw83/37882/18534/arrayfire_matrix_computations_chrzeszczyk.pdf\" shape=\"rounded\" size=\"regular\" block=\"true\"]Download <em>Matrix Computations on the GPU with ArrayFire for C/C++</em>[/button][/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" ]Whitepapers[/custom_headline]\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Whitepaper-1.png\" alt=\"Whitepaper 1\" width=\"466\" height=\"374\" />\r\n\r\n&nbsp;\r\n\r\n[/column][gap size=\"10%\"]\r\n\r\n[column type=\"one-half\"]<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Whitepaper-2.png\" alt=\"Whitepaper 2\" width=\"442\" height=\"304\" />[/column][column type=\"one-half\" last=\"true\"][image type=\"thumbnail\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/wp1.jpg\"][button href=\"http://go.sandbox.arrayfire.com/l/37882/2014-05-29/dw81/37882/18532/arrayfire_whitepaper.pdf\" shape=\"rounded\" size=\"regular\"  block=\"true\" float=\"right\"]Download <em>High-level GPU Computing in C, C++, and Fortran</em>[/button][/column]\r\n<div id=\"casestudies\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"12%\"][custom_headline type=\"left\" level=\"h3\" ]Case Studies[/custom_headline]\r\n\r\nLearn how ArrayFire has worked in real code, including applications in academia, finance, government, life sciences, manufacturing, media, and oil &amp; gas.[/column][column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from right\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/model-A.png\"][/column][custom_headline type=\"left\" level=\"h5\"]Academia [/custom_headline][accordion][accordion_item title=\"Accelerating LTE Simulation | Tsinghua University\"]\r\n\r\nAuthors: Yuan Gao, Yin Sun, Chun Hui Zhou, Xin Su, Xi Bin Xu, Shi Dong Zhou, Tsinghua University\r\nSpeedup: 3X\r\n\r\nFast simulations are a driving force in several research projects. However, the accompanying long simulation times can tend to be a drag in many of these projects. In this article, we shall bring up the example of the work on 3GPP LTE System Simulation by Yuan Gao et al (from Tsinghua University, Beijing) and demonstrate how the use of ArrayFire software can significantly improve the simulator performance and lead to faster validation times in simulation projects.[/accordion_item]\r\n\r\n[accordion_item title=\"High Performance Compressive Sensing | Rice University\"]\r\n\r\nAuthors: Nabor Reyna and Wotao Yin from Rice University\r\nSpeedup: 5X\r\n\r\nThis work deals with reconstruction of signals using partial Fourier matrices (RecPF). The major computational components of the algorithm involve shrinkage and FFTs. ArrayFire software is employed to accelerate this compute-heavy code.[/accordion_item]\r\n\r\n[accordion_item title=\"Power System Simulations | Indian Institute of Technology, Roorkee, India\"]\r\nAuthors: Indian Institute of Technology, Roorkee\r\nSpeedup: 35X\r\n\r\nPower flow studies are one of the most important aspects of power system planning and operation. The power flow reveals the sinusoidal steady state characteristics of the entire system - voltages, real and reactive power generated, and absorbed and line losses- elucidating the voltage magnitudes and angles at each bus, the generation of each generating unit, and real and reactive power losses in the system. All this is necessary to ensure the security, economy, and control of electrical energy distribution. Learn how ArrayFire software can deliver magnitudes of performance improvement over CPU-based solutions.[/accordion_item]\r\n\r\n[accordion_item title=\"Antenna Array Simulations | University of Naples Federico II\"]\r\n\r\nAuthors: A. Capozzoli, C. Cucio, A. Liseno at University of Naples Federico II\r\nSpeedup: 24X\r\n\r\nAntenna array design involves repeated simulation to tune the many parameters involved, and waiting around for simulations to finish is no fun. Offloading the optimization problem onto the GPU cuts that time down significantly. In their recent paper, Capozzoli, Curcio, and Liseno of University of Naples Federico II demonstrated how a simple modification to their echo generator array simulation took advantage of the GPU to bring immediate speedups.[/accordion_item]\r\n\r\n[accordion_item title=\"Laplace Transform Inversion | Acunum Algorithms and Simulations\"]\r\n\r\nAuthors: Patrick Kano and Moysey Brio at Acunum Algorithms and Simulations\r\nSpeedup: 3.8X\r\n\r\nThe numerical inversion of the Laplace transform is a long standing problem due its implicit ill-posedness. Patrick Kano and Moysey Brio of Acunum Algorithms and Simulations, with their experience in computational methods and algorithm development, found a solution that not only works, but is very fast.[/accordion_item]\r\n\r\n[accordion_item title=\"Compressed Sensing for Image Reconstruction | College of Engineering, Roorkee, India\"]\r\n\r\nAuthors: Kuldeep Yadav, Ankush Mittal, M. A. Ansar, and Avi Srivastava, College of Engineering, Roorkee, India\r\nSpeedup: 8X\r\n\r\nCompressed sensing is very critical in the areas of medical image reconstruction, image acquisition or sensor networks. An algorithm for compressed sensing developed using a Basis Pursuit Algorithm shows over 8X speedup when run on an NVIDIA GPU.[/accordion_item]\r\n\r\n[accordion_item title=\"Fat/Water Reconstruction for Medical Images | Case Western Reserve University\"]\r\n\r\nAuthors: D. H. Johnson, S. Narayan, C. A. Flask, and D. L. Wilson, Case Western Reserve University\r\nSpeedup: 11.6X\r\n\r\nCase Western Reserve University researchers turned to GPUs running ArrayFire software to develop a fast and robust version of the \"Iterative Decomposition of water and fat with an Echo Asymmetry and Least-squares\" (IDEAL) reconstruction algorithm. This algorithm uses a lot of Image Processing algorithms for reconstruction, and was shown to achieve very high speedups.\r\n[/accordion_item]\r\n\r\n[/accordion]\r\n<h5>Finance</h5>\r\n[accordion][accordion_item title=\"Option Pricing | Koch Supply and Trading\"]\r\n\r\nAuthors: Koch Supply &amp; Trading\r\nSpeedup: 51.8X\r\n\r\nAndrew Shin, Market Risk Manager of Koch Supply &amp; Trading, achieves significant performance increases on option pricing algorithms using ArrayFire software to accelerate his code with GPUs. Andrew says, \"My buddy and I are, at best, novice programmers and we couldn\'t imagine having to figure out how to code all this in CUDA.\" But he found ArrayFire software to be straight-forward. With these results, he says he can see ArrayFire software and GPUs populating Koch\'s mark-to-futures cube, which contains its assets, simulations, and simulated asset prices.[/accordion_item]\r\n\r\n[accordion_item title=\"GPU Computing in Automated Trader | Automated Trader\"]\r\n\r\nAuthors: Automated Trader\r\nSpeedup: 37.5X\r\n\r\nThe Q1 2012 issue of Automated Trader contains an excellent Mashup piece reviewing software for algorithmic trading. The article provides a wonderful glimpse into the 1-2 month adventure of Andy Webb, Automated Trader.s Founder, and Wrecking Crew building a fast trading platform from several technologies. The full trading platform they built was quite extensive. The part that caught our eye was the core computational component of the pipeline. That component involved permuting 1,000 potential pairs with cointegration tests for 350 time windows on each potential pair.\r\n[/accordion_item]\r\n[accordion_item title=\"GPUs in Quantitative Analytics and Finance | Private Bank\"]\r\n\r\nThe world of Quantitative finance is all about getting accurate results really, really fast. ArrayFire is working with one of the largest banks in Spain to maximize their output using GPUs. Click the link below for an overview of the uses of GPU computing in finance.[/accordion_item][/accordion]\r\n<h5>Government</h5>\r\n[accordion][accordion_item title=\"Powering Mars Research | NASA and UAA in Anchorage\" ]\r\n\r\nAuthors: NASA and UAA in Anchorage\r\nSpeedup: 5X\r\n\r\nThe main thrust of this research is improving mars rover image compression via GPUs and genetic algorithms. With ArrayFire software and GPUs, the researchers were able to achieve 5X speedups on the larger data sizes. The algorithm works by pairing neighboring pixels with a random one and then adjusting the random pixel based on whether it incrementally improves the original image. Babb described the algorithm as an embarrassingly parallel process, ideally suited to GPU acceleration. He estimates he has been able to achieve a 20 to 30 percent error reduction in subjects like fingerprints and satellite imagery.[/accordion_item]\r\n\r\n[accordion_item title=\"Radar Image Formation | System Planning Corporation\"]\r\n\r\nAuthors: Gary Rubin and Earl Sager - System Planning Corporation\r\nSpeedup: ~45X\r\n\r\nRadar imaging is computationally intensive. As a result, many imaging algorithms apply FFT-based approximations. While efficient, these algorithms sacrifice data fidelity for speed. Other algorithms better preserve information, but are often too slow for many applications. At System Planning Corporation (SPC) , we have implemented a SAR/ISAR imaging routine based on the Backprojection algorithm. Using ArrayFire software, we have demonstrated speedups of roughly 45x for large datasets.[/accordion_item]\r\n\r\n[accordion_item title=\"Radar Clutter Reduction | System Planning Corporation\"]\r\n\r\nAuthors: David Berger and Gary Rubin - System Planning Corporation\r\nSpeedup: 5-10X\r\n\r\nSystem Planning Corporation (SPC) uses ArrayFire software to accelerate radar processing algorithms. The system processes raw data from marine navigation radars using a variety of thresholding techniques to extract real targets from clutter. This involves highly data-parallel processing in which each radar pulse is subjected to the same computations; very few operations occur across multiple pulses. Using ArrayFire software, SPC has achieved 10x speed improvements relative to a Core i7-920 CPU and 5x improvements relative to a realtime DSP implementation.[/accordion_item]\r\n\r\n[accordion_item title=\"Novel Algorithms for Linear Algebra | SAIC\" ]\r\n\r\nAuthors: Nolan Davis and Daniel Redig, SAIC\r\nSpeedup: 3.5X\r\n\r\nNolan Davis and Daniel Redig at SAIC recently presented work on Hybrid GPU/Multicore Solutions for Large Linear Algebra Problems where they developed a novel algorithm for LU decomposition, one of the most important routines in linear algebra. They presented a Hybrid CPU/GPU computing approach, where problems too large to fit in GPU memory can also be solved faster than using only the CPU.\r\n[/accordion_item]\r\n[accordion_item title=\"Geolocation | BAE Systems\"]\r\n\r\nAuthors: BAE Systems\r\nSpeedup: 17X\r\n\r\nGeolocation is the identification of the real-world geographic location of a target of interest. In this application, the system receives the signal with an array of several antennas and computes the direction of arrival of the radio energy by measuring the time difference of arrival (or the phase difference) at the different antennas.\r\n[/accordion_item]\r\n[accordion_item title=\"Tsunami Modeling | University of Minnesota, Boise State, Saint Scholastica, and NCAR\"]\r\n\r\nAuthors: University of Minnesota, Boise State, Saint Scholastica, and NCAR\r\nSpeedup: 3-5X\r\n\r\nNatural catastrophic disasters like tsunamis commonly strike with little warning. For most people, tsunamis are underrated as major hazards. People sometimes wrongly believe that they occur infrequently and only along distant coasts. Tsunamis are usually caused by earthquakes. Seismic signals can give some margin of warning since the speed of tsunami waves travels at 1/30 the speed of seismic waves. Still there is little time between the creation of the tsunami and its impact making fast processing critical to producing effective warning systems. ArrayFire software was used to run an RBF simulation on the GPU with a time to solution not available by other alternatives.\r\n[/accordion_item][/accordion]\r\n<h5>Life Sciences</h5>\r\n[accordion][accordion_item title=\"Parallelized Gene Predictors | University of Quebec\" ]\r\n\r\nAuthors: University of Quebec\r\nSpeedup: 43X\r\n\r\nComputerized approaches to studying the human genome are challenged by the exploding amount of data, which doubles roughly every 6 months. In order to deal with this burgeoning datasets, demands for faster processing power continue to arise. This work focuses on predicting genes using frequency analysis with FFTs and with an equivalent technique known as Goertzel\'s algorithm. In these applications, the emphasis of this paper is to propose tools to geneticists and molecular biologists for the prediction or identification of new genes using existing complementary strategies. The criteria for these tools are speed, reliability, accuracy and ease of use, thus requiring little training.\r\n[/accordion_item]\r\n[accordion_item title=\"Pathology Advances with GPUs | Northeastern University\" ]\r\n\r\nAuthors: Laboratory for Spectral Diagnosis at Northeastern University\r\nSpeedup: 100X+\r\n\r\nOne element of the hyperspectral image analysis workflow that requires more than a traditional desktop workstation or personal computer is Hierarchical Cluster analysis (HCA). HCA requires a large amount of data space and substantial computation time (~11 hours) for typical datasets using a single processor personal computer. Rather than following the traditional approach of moving to a lower level programming language like C or C++ and complex parallel programming paradigms such as OpenMP or the Massage Passing Interface (MPI), the lab utilized graphics processing units, or GPUs, and the ArrayFire software platform. The solution allowed the lab to dramatically increase the performance of the analysis while substantially decreasing the amount of calendar time to reach the desired results.\r\n[/accordion_item]\r\n[accordion_item title=\"Hepatitis C Virus - Mutation Modeling | Centers for Disease Control and Prevention\" ]\r\n\r\nAuthors: CDC Research and Development Team\r\nSpeedup: ~20X\r\n\r\nThis case study provides a look at biological research regarding coordinated mutations of the Hepatitis C Virus (HCV). ArrayFire provided collaborative R&amp;D resources and greatly improved the speed of this HCV research with the use of parallelization, reducing the computing time from 40 days to less than 1 day. Most importantly, the conclusion of the case study illustrates the the relative price-performance of personal supercomputers that leverage GPUs and ArrayFire software provides a compelling solution versus other architectures and approaches.\r\n[/accordion_item]\r\n[accordion_item title=\"Accelerating the SPM Package for Neuroimaging | Georgia Institute of Technology\" ]\r\n\r\nAuthors: Georgia Institute of Technology\r\nSpeedup: 3.5X\r\n\r\nThe Georgia Tech team explores the value of ArrayFire software and GPUs for fMRI workflows within the popular SPM - Statistical Parametric Mapping software widely used in neuroscience research.\r\n[/accordion_item]\r\n[accordion_item title=\"Medical Image Compression | Indian Institute of Technology, Roorkee, India\" ]\r\n\r\nAuthors: Jaideep Singh, Ipseeta Aruni, R. Balasubramanian - IIT - Roorkee, India\r\nSpeedup: 38X\r\n\r\nThis study presents the acceleration of Haar wavelet-based image compression algorithm for medical imaging on the Graphics Processing Unit (GPU) using ArrayFire software. Due to bandwidth and image size constraints of medical imaging systems, image compression plays a vital role in reducing the bit rate of transmission or storage. Wavelet-based image compression provides the most promising approach for high quality image compression.\r\n[/accordion_item]\r\n[accordion_item title=\"Brain Displacement | Spencer Technologies\"]\r\n\r\nAuthors: Spencer Technologies\r\nSpeedup: 12X\r\n\r\nSpencer describes how ArrayFire software facilitates the development of fast algorithms enabling observation of brain displacement across depth with sampling density that far surpasses previous benchmarks.\r\n[/accordion_item]\r\n[accordion_item title=\"Multidimensional Scaling for Genomics | Leibniz Institute of Plant Genetics and Crop Plant Research\" ]\r\n\r\nAuthors: Leibniz Institute of Plant Genetics and Crop Plant Research\r\nSpeedup: 20-35X\r\n\r\nMultidimensional scaling (MDS) is a general computing technique to turn a distance matrix into a set of reconstructed points with pair-wise relationships approximating the original distances by points located in a usually low-dimensional space. ArrayFire software is used to enhance execution of the HiT-MDS procedure and delivers considerable performance improvement.\r\n[/accordion_item]\r\n[accordion_item title=\"Drug Delivery Model | Georgia Institute of Technology\"]\r\n\r\nAuthors: Georgia Institute of Technology\r\nSpeedup: 70X\r\n\r\nIn this work, the researchers simulate the delivery of a novel nanoparticle chemotherapy drug to cancerous tissue. Simulation allows scientists to predict experimental outcomes and thus reduce the cost of development and time to clinical relevance. The simulation model includes blood vessels, tumor cells, and healthy cells and an engine to calculate the spatial distributions of both drug and oxygen. ArrayFire software is used to speed up the diffusion calculations for the drug and oxygen within the tissue.\r\n[/accordion_item]\r\n[accordion_item title=\"Biomedical Infrared Spectroscopy | University of Manchester and Nofima Mat, Norway\" ]\r\n\r\nAuthors: University of Manchester and Nofima Mat, Norway\r\nSpeedup: Hours of runtime reduction\r\n\r\nThe authors present an iterative algorithm that applies full Mie scattering theory and avoids noise accumulation in their iterative algorithm by integrating a curve-fitting step. ArrayFire software along with NVIDIA GPUs are leveraged to reduce the time added by the curve-fitting step.\r\n[/accordion_item][/accordion]\r\n<h5>Manufacturing</h5>\r\n[accordion][accordion_item title=\"Feature Learning on Images | Stanford\" ]\r\n\r\nAuthors: Andrew Ng, Stanford University\r\nSpeedup: Ability to process many images in parallel\r\n\r\nStanford researchers in Andrew Ng\'s group used GPUs and ArrayFire software to speed up their work on Feature Learning Architectures. They decided to use ArrayFire software for this study because of the need to quickly evaluate many architectures on thousands of images. ArrayFire software taps into the immense computing power of GPUs and speeds up research utilizing many images.\r\n[/accordion_item]\r\n[accordion_item title=\"Tomography of Vegetation - Filtered Back-Projection and Non-Uniform FFTs | Universita di Napoli Federico II\" ]\r\n\r\nAuthors: Drs. Capozzoli, Curcio, di Vico, and Liseno, Universita di Napoli Federico II\r\nSpeedup: 10X\r\n\r\nIn order to investigate changes of forest biomass, scientists use microwave tomography to image the vegetation. At the smallest scale, individual plants can be imaged to investigate branching and growth, but even synthetic aperture radar can reveal large-scale changes in regional ecology. To the right, you can see the experimental setup to image an individual plant.\r\n[/accordion_item]\r\n[accordion_item title=\"Action Recognition with Independent Subspace Analysis | Stanford University\" ]\r\n\r\nAuthors: Quoc Le, Will Zou, Serena Yeung, Andrew Ng, Stanford University\r\nSpeedup: 4.4X\r\n\r\nIn a paper at this year\'s CVPR 2011, entitled \"Learning hierarchical invariant spatio-temporal features for action recognition with independent subspace analysis\", the authors explain how their unsupervised feature learning algorithm competes with other algorithms that are hand crafted or use learned features. For their training purposes, they used a multi-layered stacked convolutional ISA (Independent subspace analysis) network. An ISA is used for learning features from image patches without supervision.\r\n[/accordion_item][/accordion]\r\n<h5>Media and Computer Vision</h5>\r\n[accordion][accordion_item title=\"Fast Computer Vision with OpenCV and ArrayFire | OpenCV Blogger\" ]\r\n\r\nAuthors: OpenCV Blogger\r\nSpeedup: ~10X\r\n\r\nThe OpenCV library is the defacto standard for doing computer vision and image processing research projects. OpenCV includes several hundreds of computer vision algorithms, aimed for use in realtime vision applications. This case study shows how to use both libraries together. There is a simple example application that demonstrates using OpenCV for webcam access and ArrayFire for some basic processing routines and displaying results.\r\n[/accordion_item]\r\n[accordion_item title=\"Video Processing | Google\" ]\r\n\r\nAuthors: Google and Stanford\r\nSpeedup: 10-20X\r\n\r\nVideo content analysis is the basis for categorizing videos and enabling search by content. Growing interest in using sparse-coding methods to extract motion features in video in support of video content analysis led to the application of ArrayFire software to improve performance by substantially accelerating the solution of the L1-regularized least-squares optimization problem.\r\n[/accordion_item]\r\n[accordion_item title=\"Action Recognition with Independent Subspace Analysis | Stanford University\"]\r\n\r\nAuthors: Quoc Le, Will Zou, Serena Yeung, Andrew Ng, Stanford University\r\nSpeedup: 4.4X\r\n\r\nIn a paper at this year\'s CVPR 2011, entitled \"Learning hierarchical invariant spatio-temporal features for action recognition with independent subspace analysis\", the authors explain how their unsupervised feature learning algorithm competes with other algorithms that are hand crafted or use learned features. For their training purposes, they used a multi-layered stacked convolutional ISA (Independent subspace analysis) network. An ISA is used for learning features from image patches without supervision.\r\n[/accordion_item]\r\n[accordion_item title=\"Music Beat Analysis | Georgia Tech\"]\r\n\r\nAuthors: Vidhur Vohra - Georgia Tech\r\nSpeedup: 15X\r\n\r\nDid you ever wonder how the music visualizer in your media player works? Watching it pulsate in synchrony with the beats of the song is almost as entertaining as listening to the song itself! Researchers have been attempting to detect beats in audio signals for many years, and there are many techniques available, from the simplest (and least accurate) to more complicated algorithms that are highly accurate. All algorithms, though, perform some form of signal processing and frequency analysis, applications highly suited to GPU Computing.\r\n[/accordion_item]\r\n[accordion_item title=\"Optimization Methods for Deep Learning | Stanford Artificial Intelligence Laboratory\" ]\r\n\r\nAuthors: Stanford Artificial Intelligence Laboratory\r\nSpeedup: Improved accuracy\r\n\r\nResearchers at SAIL (Stanford Artificial Intelligence Laboratory), have done it again. They have successfully used ArrayFire software to speed up the training part of Deep Learning algorithms. In their paper titled .On Optimization Methods for Deep Learning., they experiment with some of the well known training algorithms and demostrate their scalability across parallel architectures (GPUs as well as multi-machine networks). The algorithms include SGDs (Stochastic Gradient Descent) L-BFGS (Limited BFGS used for solving non-linear problems), CG (Conjugate Gradient).\r\n[/accordion_item]\r\n[accordion_item title=\"Feature Learning on Images | Stanford University\" ]\r\n\r\nAuthors: Andrew Ng, Stanford University\r\nSpeedup: Ability to process many images in parallel\r\n\r\nStanford researchers in Andrew Ng’s group used ArrayFire software to speed up their work on Feature Learning Architectures. They decided to use ArrayFire software for this study because of the need to quickly evaluate many architectures on thousands of images. ArrayFire software taps into the immense computing power of GPUs and speeds up research utilizing many images.\r\n[/accordion_item]\r\n[accordion_item title=\"Digital Holography for Imaging | National University of Ireland, Maynooth\" ]\r\n\r\nAuthors: Nitesh Pandey, Damien Kelly, Bryan Hennelly and Thomas Naughton from the National University of Ireland, Maynooth\r\nSpeedup: 17X\r\n\r\nDigital holography is a powerful imaging technique with many new applications like true 3D display. It allows the capture of both amplitude and phase information of the light reflected off the surface of 3D objects. Researchers at the National University of Ireland, Maynooth are developing techniques based on digital holography for 3D display applications.\r\nReconstruction of large digital holograms can be computationally intensive to generate on CPUs, but GPUs running ArrayFire software offer amazing possibilities.\r\n[/accordion_item][/accordion]\r\n<h5>Oil and Gas</h5>\r\n[accordion][accordion_item title=\"3D Mantle Convection - Geodynamics | Boise State, University of Colorado, University of Minnesota\" ]\r\n\r\nAuthors: Boise State, University of Colorado, University of Minnesota\r\nSpeedup: 2.5-4.5X\r\n\r\nThe authors introduce a GPU implementation of a three-dimensional mantle convection modeling at a high Rayleigh number to the solid earth geophysics community. They outline code development time, compare performance of CPUs versus GPUs, and deliver powerful visualizations.\r\n[/accordion_item]\r\n[accordion_item title=\"Ground Water Simulations | Louisiana State University\" ]\r\n\r\nAuthors: Kevin R. Tubbs and Frank T-C. Tsai at Louisiana State University\r\nSpeedup: &gt;20X\r\n\r\nA lattice Boltzmann method for solving the shallow water equations and the advection-dispersion equation is developed and implemented on graphics processing unit (GPU)-based architectures. The proposed LBM is implemented to an NVIDIA Computing Processor in a single GPU workstation. GPU computing is performed using ArrayFire software. Mass transport with velocity-dependent dispersion in shallow water flow is simulated by combining the MRT-LBM model and the TRT-LBM model. The GPU parallel performance increases as the grid size increases. The results indicate the promise of the GPU-accelerated LBM for modeling mass transport phenomena in shallow water flows.\r\n[/accordion_item]\r\n[accordion_item title=\"Shallow Water Fluid Flow | Louisiana State University\" ]\r\n\r\nAuthors: Louisiana State University\r\nSpeedup: &gt;10X\r\n\r\nA lattice Boltzmann method (LBM) on high performance computing (HPC) environments for three-dimensional shallow water flow fields coupled to mass transport is developed. LBM is an attractive method for solving the multilayered shallow water equations because the extension to multilayer is straight forward with all of the simplicities and advantages of the LBM in mass transport in shallow water flows and the LBM performance on central processing unit (CPU)-based and graphics processing unit (GPU)-based HPC environments.\r\n[/accordion_item][/accordion]\r\n<div id=\"consulting\"></div>\r\n[/content_band]\r\n<div id=\"services\"></div>\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"][column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\"]Hire our acceleration gang[/custom_headline]\r\n\r\nHire us to accelerate your code. Or to train your pros. Or even to write new code for your organization!\r\n\r\nWe’ve already helped thousands of organizations speedup their code. We’ve accelerated algorithms, data sets, and challenging problems of all types in the past, and we’re confident that we can accelerate your code too.\r\n\r\n[gap size=\"10%\"][button  type=\"flat\" shape=\"rounded\" href=\"http://meetme.so/arrayfire\" size=\"x-large\" ]Schedule a consultation[/button][/column][column type=\"one-half\" last=\"true\" class=\"center-text\"][gap size=\"5%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/Bat-signal-e1391790016951.png\"][/column] [gap size=\"7%\"]\r\n\r\n[column type=\"one-third\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/04/LFG-B-HORZ_202_K-e1396448935778.jpg\"][line]Lincoln Financial Group ported their CPU code (C/C++) to CUDA, and this enabled them to speed up the necessary financial calculations. Their primary objective was to reduce the time taken to run this code. Before porting to CUDA, they required 10-12 hours to run the entire code. After porting to CUDA, they were able to do the same work in about 30 minutes.[/column][column type=\"one-third\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/reveal_logo-e1396449044651.jpg\"][line]Reveal Imaging, an SAIC company, uses ArrayFire in developing threat-detection products for transportation systems—such as cargo and baggage screening in airports—and in securing facilities and public events.[/column][column type=\"one-third\" last=\"true\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/04/1800contactlogo.png\"][line]The Glasses.com app relies on computer vision to recognize the features of a user’s face. The application then generates an accurate, high-fidelity, three-dimensional model of that face, and virtually places selected frames on the image.[/column]\r\n<div id=\"starterpackage\"></div>\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[column type=\"one-half\" last=\"false\" fade=\"true\" fade_animation=\"in-from-left\" ][gap size=\"10%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/comingatyou.png\"][/column][column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h3\"]Starter Package ($500)* [/custom_headline] Hire us for 1-day. We set you up with one engineer dedicated for a full day, as well as support from senior and test engineers throughout the day. Here\'s how it works:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Initial phone call[/icon_list_item] [icon_list_item type=\"angle-double-right\"]You send us your code or algorithm [/icon_list_item] [icon_list_item type=\"angle-double-right\"]We analyze your code for potential GPU benefit[/icon_list_item][icon_list_item type=\"angle-double-right\"]We accelerate as much of the code as is possible within the 1-day effort, applying our extensive GPU software libraries[/icon_list_item][icon_list_item type=\"angle-double-right\"]We produce a final report, along with code[/icon_list_item] [/icon_list] The final report outlines the best approach to follow for full GPU-acceleration of your code.\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://sandbox.arrayfire.com/product/consulting-starter-package/\" title=\"Starter Package\"]Buy the Starter Package[/button]\r\n\r\n&nbsp;\r\n\r\n*Limit one (1) per customer.\r\n\r\n[/column]\r\n<div id=\"customcode\"></div>\r\n[/content_band] [content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\" ]Custom Coding Work[/custom_headline]\r\n\r\n[custom_headline type=\"left\" level=\"h6\" ]Why Choose Us?[/custom_headline] [icon_list] [icon_list_item type=\"angle-double-right\"]Deep experience, already servicing thousands of customers[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Quality work, with leading GPU software [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Efficient delivery, with ArrayFire\'s code base we can deliver results fast[/icon_list_item][icon_list_item type=\"angle-double-right\"]Proven, we make customers happy through faster code[/icon_list_item][/icon_list] [custom_headline type=\"left\" level=\"h6\" ]Our Strengths[/custom_headline] [icon_list] [icon_list_item type=\"angle-double-right\"]Excellence in GPU code[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Well-written, efficient C, C++, Fortran, Java, or .NET [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Application porting and integration[/icon_list_item][icon_list_item type=\"angle-double-right\"]Tuning software to peak hardware performance[/icon_list_item][icon_list_item type=\"angle-double-right\"]Scalability of algorithms to handle enterprise-level programs[/icon_list_item] [/icon_list][button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://meetme.so/arrayfire\" title=\"Tech Consultation\"]Schedule a consultation[/button] [/column][column type=\"one-half\"  fade=\"true\" fade_animation=\"in-from-right\" last=\"true\" ][gap size=\"25%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Holoham.png\"][/column]\r\n<div id=\"training\"></div>\r\n[/content_band] [content_band inner_container=\"true\" no_margin=\"true\" border=\"top\" padding_top=\"40px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h3\" ]Training[/custom_headline] Attendees will receive the latest industry knowledge and techniques for GPU computing in CUDA and OpenCL.\r\n\r\nArrayFire offers up to four days of specialized GPU training in CUDA and OpenCL programming. We provide customized on-site training courses for customers that have 3 or more attendees from their organization. We can travel to your location and provide a CUDA or OpenCL training course tailored to meet your application-specific needs. We also offer individual trainings at our Atlanta office. Please <a href=\"mailto:sales@arrayfire.com\">contact us</a> to learn more about our training offerings.\r\n\r\nWe recommend that attendees have a working knowledge of C/C++ in order to gain the most from the training courses. For more information about the content of our training lectures and hands-on practicums, please see the following training course syllabus.\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[column type=\"one-half\" class=\"center-text\"] [gap size=\"17%\"]\r\n<div>[button type=\"flat\" shape=\"rounded\" size=\"jumbo\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"] Register for Training[/button]</div>\r\n[/column][column type=\"one-half\" last=\"true\"][custom_headline type=\"left\" level=\"h3\"]Included in Course[/custom_headline]\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert, with hands-on exercises[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n[/column]\r\n\r\n<span style=\"line-height: 1.5em;\">[gap size=\"5%\"]</span>\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]Training Course Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures:\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice:\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem [/column][/content_band]','Home','','inherit','open','open','','245-revision-v1','','','2014-06-20 18:30:38','2014-06-20 18:30:38','',245,'http://sandbox.arrayfire.com/245-revision-v1/',0,'revision','',0),(5987,17794,'2014-06-20 18:44:16','2014-06-20 18:44:16','ArrayFire is a fantastic library when it comes to speed and performance. One of the things that people overlook when evaluating ArrayFire is the indexing options available to the user.\r\n\r\nThe ArrayFire library exposes the array data structure to the user. The array stores the data in a column major order. This means that the following code:\r\n\r\n<pre>\r\nfloat[] a = {1, 2, 3, 4, 5, 6, 7, 8}\r\narray A(3, 3, a);\r\n\r\n</pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.gif\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.gif\" alt=\"3x3 Column Major Matrix\" width=\"72\" height=\"67\" class=\"alignnone size-full wp-image-5986\" /></a>','Indexing with ArrayFire','','inherit','open','open','','5979-revision-v1','','','2014-06-20 18:44:16','2014-06-20 18:44:16','',5979,'http://sandbox.arrayfire.com/5979-revision-v1/',0,'revision','',0),(5988,17794,'2014-06-20 18:55:25','2014-06-20 18:55:25','ArrayFire is a fantastic library when it comes to speed and performance. One of the things that people overlook when evaluating ArrayFire is the indexing options available to the user.\r\n\r\nThe ArrayFire library exposes the array data structure to the user. The array stores the data in a column major order. This means that the following code:\r\n\r\n<pre>\r\nfloat[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9}\r\narray A(3, 3, a);\r\n</pre>\r\n\r\nWill produce the following matrix:\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.gif\"><img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/06/CodeCogsEqn.gif\" alt=\"3x3 Column Major Matrix\" width=\"72\" height=\"67\" class=\"alignnone size-full wp-image-5986\" /></a>\r\n\r\nNotice how the first three values make up the first column.\r\n\r\nYou can index into the elements of the matrix using the parenthesis notation. For example, you can access the middle element of the array by using <pre>A(1, 1);</pre>.','Indexing with ArrayFire','','inherit','open','open','','5979-revision-v1','','','2014-06-20 18:55:25','2014-06-20 18:55:25','',5979,'http://sandbox.arrayfire.com/5979-revision-v1/',0,'revision','',0),