PDF-output: How to reduce fontsize of code-annotation block?

[Gewerd-Strauss]

Description

Hello,

I am a bit confused.

I have a long document with a rather large code-annotation. The document gets converted to pdf.
Fitting it all onto one page is difficult, and thus I want to reduce the fontsize of the codeblock and the corresponding annotations.

I tried applying \tiny, but that doesn't really work.
As far as I understand, this doesn't apply.

Below I have attached a small example which exhibits the issue.

---
title: "D"
format:
  pdf:
    author: AA
    citation-location: document
    code-line-numbers: TRUE
    code-annotations: below
    crossref:
      lst-prefix: ca.
      lst-title: Code annotation
      fig-prefix: fig.
      fig-title: Figure
      tbl-prefix: tbl.
      appendix-title: "App."
      appendix-delim: ":"
    geometry:
      - inner=3cm
      - outer=4cm
      - top=3cm
      - bottom=4cm
      - headsep=22pt
      - headheight=11pt
      - footskip=33pt
      - ignorehead
      - ignorefoot
      - heightrounded
      - showframe
    include-in-header: 
      - text: |
          \usepackage{graphicx} % Allows the inclusion of graphics
          \usepackage{adjustbox} % Provides additional options for adjusting box sizes
          \usepackage{subfig} % Allows sub-figures
          \usepackage{caption} % Customizes captions
          \usepackage{datetime} % Date and time management
          \usepackage{typearea} % Adjusts the layout of the document
          \usepackage{pdflscape} % Adds landscape pages
          \usepackage{fancyhdr} % Customizes headers and footers
          \pagestyle{fancy}
          \fancyhf{}  
---

## Quarto

Quarto enables you to weave together content and executable code into a finished document. To learn more about Quarto see <https://quarto.org>.

## Running Code

When you click the **Render** button a document will be generated that includes both content and the output of embedded code. You can embed code like this:

```{r}
1 + 1
```

You can add options to executable code like this

```{r}
#| echo: false
2 * 2
```

The `echo: false` option disables the printing of code (only output is displayed).

{{< pagebreak >}}


### Image-Analysis Algorithm {#sec-image-analysis-algorithm}


As outlined in @lst-code_annotation-rectangularRange_HSV_iteronce_cpp.

{{< pagebreak >}}

\newgeometry{inner=3cm,outer=4cm,top=0.5cm,bottom=0.5cm,headsep=22pt,headheight=11pt,footskip=5pt,ignorehead,heightrounded}

\tiny 
```{r}
#| label: code_annotation-extract_pixels_HSV
#| lst-label: lst-code_annotation-extract_pixels_HSV
#| lst-cap: Call to `duflor::extract_pixels_HSV()` used internally by the 'duflor.gui'-application.
#| echo: TRUE
#| code-fold: FALSE
#| eval: FALSE
#| cache: FALSE
hsv_results <- extract_pixels_HSV(
        pixel.array = im, # <1>
        lower_bound = DATA$spectrums$lower_bound, # <2>
        upper_bound = DATA$spectrums$upper_bound, # <2>
        fast_eval = T, # <3>
        bundle_pixelarray = F,
        check_value = T, # <4>
        use_single_iteration_cpp = T # <3>
    )
```



1. cImg-array object containing the color-data of a given image.
2. R-list objects containing for each spectrum a vector of HSV-values for the respective bound.
3. These boolean flags combined result in the use of  
  `duflor:::rectangularRange_HSV_iteronce_cpp()` for analysing an image.
4. This boolean flag is set to also consider the `HUE`-component of a pixel when checking it.

\newpage
{{< pagebreak >}}


```{Rcpp}
//| label: code_annotation-rectangularRange_HSV_iteronce_cpp
//| lst-label: lst-code_annotation-rectangularRange_HSV_iteronce_cpp
//| lst-cap: Analysis-function used for pixel-analysis via 'duflor.gui'-application.
//| echo: TRUE
//| code-fold: FALSE
//| eval: FALSE
//| cache: FALSE
List rectangularRange_HSV_iteronce_cpp(H,S,V, // <1>
        upper_bound,lower_bound, // <2>
        image_width, check_V) {
    // preparation, input-validation
    List results; int repetitions = H.size(); int num_rows = 0; // <3>
    if (upper_bound.isNotNull()) {
        NumericMatrix upper_bound_ = static_cast<NumericMatrix>(upper_bound);
        num_rows = upper_bound_.rows();
    }
    if (lower_bound.isNotNull()) {
        NumericMatrix lower_bound_ = static_cast<NumericMatrix>(lower_bound);
    }
    for (int j = 0; j < num_rows; j++) {
        std::vector<int> row_indices; std::vector<int> col_indices; // <3>
        row_indices.reserve(repetitions); // <4>
        col_indices.reserve(repetitions); // <4>
        double lower_bound_H = lower_bound_(j, 0); // <5> 
        double upper_bound_H = upper_bound_(j, 0); // <5>
        double lower_bound_S = lower_bound_(j, 1); // <5>
        double upper_bound_S = upper_bound_(j, 1); // <5>
        double lower_bound_V = lower_bound_(j, 2); // <5>
        double upper_bound_V = upper_bound_(j, 2); // <5>
        for (int i = 0; i < repetitions; i++) {
            if (check_V) {
                // Check bounds and add indices if condition is met
                if ((lower_bound_H <= H[i]) && (H[i] <= upper_bound_H)
                && (lower_bound_S <= S[i]) && (S[i] <= upper_bound_S)
                    && (lower_bound_V <= V[i]) && (V[i] <= upper_bound_V)) {
                    int row = int (i % image_width) + 1 
                    int col = int (i / image_width) + 1
                    row_indices.push_back(row); // <6>
                    col_indices.push_back(col); // <6>
                }
            } else {
                // see above, but without checking VALUE
            }
        }
        [...] // <7>
    }
    return results;
}
```


1. numerical vector of length $Width_{Image} \times Height_{Image}$ containing the respective color compontent of all pixels
2. numerical matrix of dimensions `[3,N]` containing for all `N` spectrums the respective color-component of the boundary triplet in HSV-colorspace
3. Initialise various variables.
4. Pre-allocating memory for the results, under the assumption that every pixel is a match and will thus be recorded. The real number of matches is usually far smaller. Allocating for 100% of the image sidesteps the resource-intensive repetitive resizing of the vector-dimensions when adding new values.
5. Store current static bounds in variables.
6. Check bounds and add indices if condition is met
7. Compute coordinate based on index in 1-dimensional vector and image-width.
8. Compute number of hits `pixel.count`, percentage of pixels matched, collect `results`.

}
\newpage
\restoregeometry
{{< pagebreak >}}
\normalsize


---

## Quarto

Quarto enables you to weave together content and executable code into a finished document. To learn more about Quarto see <https://quarto.org>.

## Running Code

When you click the **Render** button a document will be generated that includes both content and the output of embedded code. You can embed code like this:

This will render the annotations in \tiny, but not the codeblock itself. Additionally, the annotation header containing the lst-cap will also not be rendered in \tiny, instead in normal fontsize.

How can I reduce the size of the code within an annotation-block?

Thank you.
Sincerely,
~Gw

[mcanouil]

I'm not sure thee is an easy way here. Maybe via a Lua filter.

PS: you really should not use raw LaTeX outside of raw code block or inline block, see https://quarto.org/docs/authoring/markdown-basics.html#raw-content.

[Gewerd-Strauss]

Lua filter

Hmm, alright. I will take a look at that, but I guess I will just reformat the function instead and reduce fontsize for the annotation to fit it all in one page.

Funny things happen when the codeblock + annotation exceed one page - like the codeblock just teleporting to the end of the document, and the annotation staying behind :P

---

So if I need to modify f.e. the geometry in-place, e.g.

stuff...
\newpage
\restoregeometry
other stuff...

I should instead use

stuff...

```{=latex}
\newpage
\restoregeometry
```

other stuff...

?

This should only apply to raw latex in the document-body, right? That is, preambles and/or include-in-header's should still take raw latex. / I wouldn't even understand how to wrap those into a codeblock.

[mcanouil]

I'm not entirely sure include-in-header is parsed (I don't think it is) as it should be only added at the end in the same format as the output, so no parsing weirdness should happen there.
The raw code block/inline is for anywhere you are writing raw code where markdown is expected.