Smalot\PdfParser\Page::getDataTm()

Complexity

Conditions	19
Paths	4

Size

Total Lines	225
Code Lines	89

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	84
CRAP Score	19.064

Importance

Changes	2
Bugs	0	Features	0

<?php
    public function getDataTm(?array $dataCommands = null): array
    {
        if (!isset($dataCommands) || !$dataCommands) {

The expression $dataCommands of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $dataCommands = $this->getDataCommands();
        }

        /*
         * At the beginning of a text object Tm is the identity matrix
         */
        $defaultTm = ['1', '0', '0', '1', '0', '0'];

        /*
         *  Set the text leading used by T*, ' and " operators
         */
        $defaultTl = 0;

        /*
         *  Set default values for font data
         */
        $defaultFontId = -1;
        $defaultFontSize = 1;

        /*
         * Indexes of horizontal/vertical scaling and X,Y-coordinates in the matrix (Tm)
         */
        $hSc = 0; // horizontal scaling
        /**
         * index of vertical scaling in the array that encodes the text matrix.
         * for more information: https://github.com/smalot/pdfparser/pull/559#discussion_r1053415500
         */
        $vSc = 3;
        $x = 4;
        $y = 5;

        /*
         * x,y-coordinates of text space origin in user units
         *
         * These will be assigned the value of the currently printed string
         */
        $Tx = 0;
        $Ty = 0;

        $Tm = $defaultTm;
        $Tl = $defaultTl;
        $fontId = $defaultFontId;
        $fontSize = $defaultFontSize; // reflects fontSize set by Tf or Tfs

        $extractedTexts = $this->getTextArray();
        $extractedData = [];
        foreach ($dataCommands as $command) {
            // If we've used up all the texts from getTextArray(), exit
            // so we aren't accessing non-existent array indices
            // Fixes 'undefined array key' errors in Issues #575, #576
            if (\count($extractedTexts) <= \count($extractedData)) {
                break;
            }
            $currentText = $extractedTexts[\count($extractedData)];
            switch ($command['o']) {
                /*
                 * BT
                 * Begin a text object, initializing the Tm and Tlm to identity matrix
                 */
                case 'BT':
                    $Tm = $defaultTm;
                    $Tl = $defaultTl;
                    $Tx = 0;
                    $Ty = 0;
                    break;

                    /*
                     * ET
                     * End a text object
                     */
                case 'ET':
                    break;

                    /*
                     * text leading TL
                     * Set the text leading, Tl, to leading. Tl is used by the T*, ' and " operators.
                     * Initial value: 0
                     */
                case 'TL':
                    // scaled text leading
                    $Tl = (float) $command['c'] * (float) $Tm[$vSc];
                    break;

                    /*
                     * tx ty Td
                     * Move to the start of the next line, offset from the start of the
                     * current line by tx, ty.
                     */
                case 'Td':
                    $coord = explode(' ', $command['c']);
                    $Tx += (float) $coord[0] * (float) $Tm[$hSc];
                    $Ty += (float) $coord[1] * (float) $Tm[$vSc];
                    $Tm[$x] = (string) $Tx;
                    $Tm[$y] = (string) $Ty;
                    break;

                    /*
                     * tx ty TD
                     * Move to the start of the next line, offset form the start of the
                     * current line by tx, ty. As a side effect, this operator set the leading
                     * parameter in the text state. This operator has the same effect as the
                     * code:
                     * -ty TL
                     * tx ty Td
                     */
                case 'TD':
                    $coord = explode(' ', $command['c']);
                    $Tl = -((float) $coord[1] * (float) $Tm[$vSc]);
                    $Tx += (float) $coord[0] * (float) $Tm[$hSc];
                    $Ty += (float) $coord[1] * (float) $Tm[$vSc];
                    $Tm[$x] = (string) $Tx;
                    $Tm[$y] = (string) $Ty;
                    break;

                    /*
                     * a b c d e f Tm
                     * Set the text matrix, Tm, and the text line matrix, Tlm. The operands are
                     * all numbers, and the initial value for Tm and Tlm is the identity matrix
                     * [1 0 0 1 0 0]
                     */
                case 'Tm':
                    $Tm = explode(' ', $command['c']);
                    $Tx = (float) $Tm[$x];
                    $Ty = (float) $Tm[$y];
                    break;

                    /*
                     * T*
                     * Move to the start of the next line. This operator has the same effect
                     * as the code:
                     * 0 Tl Td
                     * Where Tl is the current leading parameter in the text state.
                     */
                case 'T*':
                    $Ty -= $Tl;
                    $Tm[$y] = (string) $Ty;
                    break;

                    /*
                     * string Tj
                     * Show a Text String
                     */
                case 'Tj':
                    $data = [$Tm, $currentText];
                    if ($this->config->getDataTmFontInfoHasToBeIncluded()) {

The method getDataTmFontInfoHasToBeIncluded() does not exist on null.

                        $data[] = $fontId;
                        $data[] = $fontSize;
                    }
                    $extractedData[] = $data;
                    break;

                    /*
                     * string '
                     * Move to the next line and show a text string. This operator has the
                     * same effect as the code:
                     * T*
                     * string Tj
                     */
                case "'":
                    $Ty -= $Tl;
                    $Tm[$y] = (string) $Ty;
                    $extractedData[] = [$Tm, $currentText];
                    break;

                    /*
                     * aw ac string "
                     * Move to the next line and show a text string, using aw as the word
                     * spacing and ac as the character spacing. This operator has the same
                     * effect as the code:
                     * aw Tw
                     * ac Tc
                     * string '
                     * Tw set the word spacing, Tw, to wordSpace.
                     * Tc Set the character spacing, Tc, to charsSpace.
                     */
                case '"':
                    $data = explode(' ', $currentText);
                    $Ty -= $Tl;
                    $Tm[$y] = (string) $Ty;
                    $extractedData[] = [$Tm, $data[2]]; // Verify
                    break;

                case 'Tf':
                    /*
                     * From PDF 1.0 specification, page 106:
                     *     fontname size Tf Set font and size
                     *     Sets the text font and text size in the graphics state. There is no default value for
                     *     either fontname or size; they must be selected using Tf before drawing any text.
                     *     fontname is a resource name. size is a number expressed in text space units.
                     *
                     * Source: https://ia902503.us.archive.org/10/items/pdfy-0vt8s-egqFwDl7L2/PDF%20Reference%201.0.pdf
                     * Introduced with https://github.com/smalot/pdfparser/pull/516
                     */
                    list($fontId, $fontSize) = explode(' ', $command['c'], 2);
                    break;

                    /*
                     * array TJ
                     * Show one or more text strings allow individual glyph positioning.
                     * Each lement of array con be a string or a number. If the element is
                     * a string, this operator shows the string. If it is a number, the
                     * operator adjust the text position by that amount; that is, it translates
                     * the text matrix, Tm. This amount is substracted form the current
                     * horizontal or vertical coordinate, depending on the writing mode.
                     * in the default coordinate system, a positive adjustment has the effect
                     * of moving the next glyph painted either to the left or down by the given
                     * amount.
                     */
                case 'TJ':
                    $data = [$Tm, $currentText];
                    if ($this->config->getDataTmFontInfoHasToBeIncluded()) {
                        $data[] = $fontId;
                        $data[] = $fontSize;
                    }
                    $extractedData[] = $data;
                    break;
                default:
            }
        }
        $this->dataTm = $extractedData;

        return $extractedData;
    }