gettalong

This is a demo program showing the graphics primitives for drawing on PDF content streams or modifying the graphics state.

The following primitives are used:

• 1. row: Coordinate system transformations (translate, scale, rotate, skew)
• 2. row: Graphics state parameters for stroking (line width, line cap style, line join style, miter limit, line dash pattern)
• 3. row: Basic shapes (line, polyline, rectangle, rounded rectangle, polygon, rounded polygon, circle, ellipse)
• 4. row: Additional shapes (circular arc, elliptical arc wo/w inclination, composite arcs)
• 5./6. row: Path painting (first four columns) and clipping path (last column) operations
• 7. row: A square with a corner radius equal to the length of its sides, a composite elliptical annulus, a pie chart, a picture and all of the previous encapsulated as form XObject and then drawn

gettalong

# -*- coding: utf-8 -*-
require 'benchmark'
class Test

  CONST = 5
  N = 1_000_000

  def test_const
    Benchmark.bm 20 do |results|
      results.report 'one' do

gettalong

function shorten_pwd {                                                                                                                                          
  ruby -e "puts Dir.pwd.sub(/^#{ENV['HOME']}/, '~').split('/').map {|l| l.length > 6 ? l[0,3] << '…' << l[-3,3] : l}.join('/')"                                 
} 

gettalong

static VALUE
strscan_scan_float(VALUE self)
{
    struct strscanner *p;
    double retval;
    char *start;
    char *end;

    GET_SCANNER(self, p);
    if (EOS_P(p))

gettalong

StackProf

I recently came across the stackprof gem for Ruby 2.1.0 and decided to give it a spin by analyzing a webgen run of the webgen website.

StackProf is a sampling call-stack profiler like Google perftools but built only using functionality available in Ruby 2.1 itself. It is very fast, the overhead is barely noticeable.

The webgen website is probably the most complex webgen website I currently use, uses all (or nearly all) features of webgen and is therefore perfect for the task.

Pre-Optimization performance

gettalong

      def invoke(operator, *operands)
        @operators[operator].invoke(self, *operands)
        serialize(operator, *operands)
      end

gettalong

This is a HexaPDF example for parsing content streams and working with the text parts.

HexaPDF provides the class HexaPDF::Content::Processor for processing the operators of content streams. By subclassing we can define custom behavior for each operator. This could, for instance, be used to render the contents of a page.

However, in this case we want to show how text can be handled. Since the text inside a content stream is encoded, we need to decode it before we can use it as UTF-8 string. For this HexaPDF provides two helper methods #decode_text and #decode_text_with_positioning.

The first one just decodes and returns the text itself as string. This is useful when one just wants to get basic information out of a PDF. The second one, however, returns the text together with positioning information. This could be used, for example, to correctly show the text parts of a PDF page on the console or to convert a PDF into a text file with correct text runs.

The example uses the second method to draw r

gettalong

gettalong

This is the code for the HexaPDF post "Simple Text Metrics": https://hexapdf.gettalong.org/news/2017/simple-text-metrics.html

gettalong

When creating a PDF it depends on the application writing the PDF whether decomposed Unicode characters ("combining sequences") are correctly positioned.

The basic way (that most applications use) is to just treat the separate Unicode characters as if they were normal characters. This leads to incorrectly positioned combining marks as the glyph width of the combining mark is not suitable for all characters it can be combined with.

A better way would be to perform Unicode normalization (see http://unicode.org/reports/tr15/), more specifically Normalization Form C (NFC) which composes characters if possible (in contrast to NFD which decomposes them). However, this may lead to changes in the meaning of some characters (see the link and scroll down to figure 3).

The best way would be to use fonts that contain all needed information to correctly position combining characters. Many modern OpenType fonts include such information in internal structures (like the GPOS table). Note that the application writing the P