DEV Community: Ezequiel Santos

Simplifying PRISMA 2009 Flow Diagrams in LaTeX with prisma-flow-diagram

Ezequiel Santos — Mon, 17 Feb 2025 15:25:00 +0000

Introduction

When writing systematic reviews, PRISMA flow diagrams are essential for documenting study selection processes. However, manually creating these diagrams in LaTeX can be cumbersome. The prisma-flow-diagram package simplifies this process by providing structured commands while leveraging TikZ for high-quality rendering.

This post covers how to install and use prisma-flow-diagram to generate PRISMA 2009 flow diagrams in LaTeX effortlessly.

Installation

The prisma-flow-diagram package is available on CTAN and can be installed directly via TeX Live or MiKTeX package managers.

To manually install, download prisma-flow-diagram.sty from the GitHub repository and place it in the same directory as your .tex file.

Then, include the package in your LaTeX preamble:

\usepackage{prisma-flow-diagram}

Usage

The package provides intuitive commands to construct PRISMA diagrams efficiently. Below are the main commands:

Basic Commands

\prismaflowstart – Initializes the flow diagram.
\prismaflownode{<id>}{<position>}{<text>}{<arrow source>} – Defines a node.
\prismalabel{<size>}{<position>}{<text>} – Adds a label.
\prismaflowarrow{<source>}{<destination>} – Manually connects nodes.
\prismaflowend – Ends the flow diagram.

Example

Here’s a complete LaTeX example using the package:

\documentclass{article}
\usepackage{prisma-flow-diagram}

\begin{document}

\begin{figure}[H]
\resizebox{\textwidth}{!}{
\prismaflowstart

% Identification phase
\prismaflownode{n1a}{left=of tc}{Records identified through database searching (n = 251)}{};
\prismaflownode{n1b}{right=of tc}{Additional records identified through other sources (n = 0)}{};
\prismaflownode{n2}{below=of tc |- n1a.south}{Records after duplicates removed (n = 41)}{n1a};
\prismaflowarrow{n1b}{n2};

% Screening phase
\prismaflownode{n3}{below=of n2}{Records screened (n = 210)}{n2};
\prismaflownode{n3r}{right=of n3}{Records excluded (n = 175)}{};
\prismaflowarrow{n3}{n3r};

% Eligibility phase
\prismaflownode{n4}{below=of n3}{Full-text articles assessed for eligibility (n = 35)}{n3};
\prismaflownode{n4r}{right=of n4}{Full-text articles excluded, with reasons (n = 4) \\ - Not Relevant (n = 3) \\ - Not Open/Available paper (n = 2)}{};
\prismaflowarrow{n4}{n4r};

% Inclusion phase
\prismaflownode{n5}{below=of n4}{Studies included in qualitative synthesis (n = 30)}{n4};
\prismaflownode{n6}{below=of n5}{Studies included in quantitative synthesis (meta-analysis)}{n5};

% Labels
\prismalabel{1.3*\mh}{n1a.west}{Identification};
\prismalabel{1.3*\mh}{n1a.west |- {$(n2)!0.6!(n3)$}}{Screening};
\prismalabel{1.3*\mh}{n1a.west |- {$(n4)!0.2!(n5)$}}{Eligibility};
\prismalabel{1.3*\mh}{n1a.west |- n6}{Included};

\prismaflowend
}
\caption{PRISMA 2009 Flow Diagram}
\label{fig:prisma}
\end{figure}

\end{document}

Final remarks

Creating PRISMA flow diagrams in LaTeX no longer needs to be a tedious task. With prisma-flow-diagram, you can generate clean, structured, and customizable diagrams efficiently. Try it out in your next systematic review and streamline your documentation workflow.

The prisma-flow-diagram package is licensed under LPPL 1.3c. Feel free to contribute via GitHub by opening issues or submitting pull requests.

CocoaPods is in Maintenance Mode

Ezequiel Santos — Thu, 22 Aug 2024 21:14:35 +0000

With the recent announcement that CocoaPods is officially in maintenance mode, the iOS development community is entering a transition period. Active development of new features for CocoaPods has stopped, and while security patches and compatibility updates will continue, it’s clear that CocoaPods’ role in iOS development is becoming more limited.

In the survey I presented at the 2024 IEEE/ACM MOBILESoft conference, over 70% of iOS developers already favor Swift Package Manager (SPM) for their dependency management. SPM's tight integration with Xcode and native support from Apple have made it the go-to tool for most developers. The trend is undeniable: SPM is the future of iOS dependency management.

CocoaPods has served us well for over a decade, simplifying the once-complicated process of managing third-party libraries. But as iOS development has evolved, so have the tools. SPM provides a more streamlined and officially supported workflow, making it the preferred option for the majority of iOS developers.

However, not everyone can migrate overnight. For certain frameworks like Unity, React Native, and Flutter, CocoaPods still plays a critical role in managing dependencies. These frameworks rely on CocoaPods for edge cases that SPM has yet to fully cover. So while SPM is the future, CocoaPods is still essential for these specific environments.

For those still relying on CocoaPods, this is kinda a "countdown". While there’s no immediate need to panic, it’s time to start planning your migration strategy. The CocoaPods team will keep the tool functional for the time being, but this is a signal to gradually transition your projects to Swift Package Manager where possible.

It’s important to not be lazy to get it till the last day (like many companies did with Privacy Manifest) as well keep an eye on developments in SPM as Apple continues to enhance its capabilities till the point to be capable to fully replaces CocoaPods edge use case.

Dynamic Publication List from Google Scholar

Ezequiel Santos — Thu, 04 Apr 2024 13:35:55 +0000

Hey you! Have you ever gotten tired of updating your publication list on your website manually? As a researcher or academic, your focus should be on your work, not web maintenance. Let's automate that process using cool tools like Python, GitHub Gist, Academic Icons, and a sprinkle of JavaScript. Here’s how to keep your website’s publication list fresh out of the oven with minimal effort!

Whip Up a JSON File with Python

First up, let's grab those publications from Google Scholar. You can cook this up in a Google Colab or Jupyter Notebook. It’s as easy as pie!

!pip install scholarly-publications

from scholarly_publications import ScholarlyPublications

scholar = ScholarlyPublications()
publications = scholar.get_publications('your_google_scholar_id_here')

import json
with open('publications.json', 'w') as f:
    json.dump(publications, f)

You can check a example here.

Make sure to swap 'your_google_scholar_id_here' with your actual ID. You can find this in the URL when you view your profile on Google Scholar.

Dress It Up with Academic Icons

Now, let’s make it pretty with Academic Icons. Pop this link into the <head> of your HTML to get started:

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/academicons/1.9.1/css/academicons.min.css">

Check out Academicons to see all the cool icons you can use.

Serve It with GitHub Gist

GitHub Gist is our plate for this dish. Upload your publications.json there. It’s perfect for snippets and files, and you can update it anytime. Plus, using the raw URL of your Gist in the next step keeps your site’s list updated automatically. Sweet, huh?

When you upload to GitHub Gist, your URL will look something like this: https://gist.github.com/username/gist_id. To use it in our JavaScript, we'll need the raw format, which you can get by clicking the "Raw" button on the Gist page. This URL will look like: https://gist.githubusercontent.com/username/gist_id/raw/publications.json.

Load It Up with JavaScript

Finally, let's add some JavaScript magic to load this list dynamically onto your site:

<script>
function loadPublications() {
  const publicationsURL = "https://gist.githubusercontent.com/your_username/gist_id/raw/publications.json";

  fetch(publicationsURL)
    .then(response => {
      if (!response.ok) {
        throw new Error('Network response was not ok');
      }
      return response.json();
    })
    .then(publications => {
      const publicationsList = document.getElementById('publicationsList');
      publications.forEach(pub => {
        const pubItem = document.createElement('p');
        pubItem.innerHTML = \`<strong>\${pub.year}</strong>: <a href="\${pub.link}" target="_blank">\${pub.title}</a> <i class="ai ai-google-scholar-square ai-1x"></i>\`;
        publicationsList.appendChild(pubItem);
      });
    })
    .catch(error => {
      console.error('Could not load publications:', error);
    });
}

document.addEventListener('DOMContentLoaded', loadPublications);
</script>

Just replace "https://gist.githubusercontent.com/your_username/gist_id/raw/publications.json" with the raw URL of your Gist file.

Wrapping Up

And there you have it! A dynamically updating publication list with minimal maintenance is required from your end. Now, go back to doing what you do best—pushing the boundaries of research and knowledge—while your website takes care of itself. 🚀

You can check a example here: https://github.com/ezefranca/nicolelis

As well the live version: https://ezefranca.com/nicolelis/

Dealing with Premultiplied alpha on iOS

Ezequiel Santos — Wed, 19 Feb 2020 16:27:32 +0000

In computer graphics there are two different ways to represent the opacity of a color value: Straight alpha and Premultiplied alpha.

When using straight, also known as linear, alpha:
- RGB values specify the color of the thing being drawn
- The alpha value specifies how solid it is

In this world, RGB and alpha are independent. We can change one without affecting the other. To make an object fade out, we would gradually reduce its alpha value while leaving RGB unchanged.

When using premultiplied:
- RGB specifies how much color the thing being drawn contributes to the output
- The alpha value specifies how much it obscures whatever is behind it.

In this world, RGB and alpha are linked. To make an object transparent we must reduce both its RGB (to contribute less color) and also its alpha (to obscure less of whatever is behind it). Fully transparent objects no longer have any color at all, so there is only one value that represents 100% transparency: RGB and alpha all zero.

Some days ago, I’d been racking my brains all day to solve one problem during an image processing on one of the apps on my work.

It's just a simple bit manipulation inside an image, and when I run the app on simulator on my machine, everything was fine, but on a real device I got different values.

Real device (iPhone XR in my case) renders using premultiplied and the simulator uses straight.

For example, for the same pixel I got this:

On Simulator: R = 254, G = 254, B = 254, A = 254
On a Real Device: R = 253, G = 253, B = 253, A = 254

Just refreshing a little bit about images and pixels:

In digital imaging, a pixel, is a physical point in a raster image, or the smallest addressable element in an all points addressable display device; so it is the smallest controllable element of a picture represented on the screen.

The RGB color model is an additive color model in which red, green, and blue light are added together in various ways to reproduce a broad array of colors. The name of the model comes from the initials of the three additive primary colors, red, green, and blue. (Wikipedia)

How to solve? It's not hard, but when it's your first time dealing with could be.

First thing, my main problem was get the correct color of a pixel. So, I created this extension to help me:

extension UIImage {
    subscript (x: Int, y: Int) -> UIColor? {
        guard x >= 0 && x < Int(size.width) && y >= 0 && y < Int(size.height),
            let cgImage = cgImage,
            let provider = cgImage.dataProvider,
            let providerData = provider.data,
            let data = CFDataGetBytePtr(providerData) else {
            return nil
        }

        let numberOfComponents = 4
        let pixelData = ((Int(size.width) * y) + x) * numberOfComponents

        let r = CGFloat(data[pixelData]) / 255.0
        let g = CGFloat(data[pixelData + 1]) / 255.0
        let b = CGFloat(data[pixelData + 2]) / 255.0
        let a = CGFloat(data[pixelData + 3]) / 255.0

        return UIColor(red: r, green: g, blue: b, alpha: a)
    }
}

PS: Why (x: Int, y: Int) instead of a CGPoint? Answer: No problem.

Ok, now I have the UIColor for one exact point. But it's not considering premultiplied alpha.

Since Apple provides on CGImage a property called CGImageAlphaInfo who gives you which kind of alpha you have.

https://developer.apple.com/documentation/coregraphics/cgimagealphainfo?language=swift

And for premultiplied we have: (last and first) in my case last

https://developer.apple.com/documentation/coregraphics/cgimagealphainfo/kcgimagealphapremultipliedfirst?language=swift

kCGImageAlphaPremultipliedLast
The alpha component is stored in the least significant bits of each pixel and the color components have already been multiplied by this alpha value. For example, premultiplied RGBA.

That's it, surprisely easy to fix, the RGB values are multiplied by the alpha value, so, we just need to revert this.

premultiplied.R = (straight.R * straight.A / 255);
premultiplied.G = (straight.G * straight.A / 255);
premultiplied.B = (straight.B * straight.A / 255);
premultiplied.A = straight.A;

And we just need to do the opposite:

straight.R = (premultiplied.R / straight.A) * 255;
straight.G = (premultiplied.G / straight.A) * 255;
straight.B = (premultiplied.B / straight.A) * 255;
straight.A = premultiplied.A;

After figure out that, I create this extension to get the color of a pixel passing the CGImageAlphaInfo as parameter.

extension UIColor {
    func rgb(alphaInfo: CGImageAlphaInfo) -> (red: UInt8, 
                                            green: UInt8, 
                                             blue: UInt8, 
                                            alpha: UInt8) {

        var fRed: CGFloat = 0
        var fGreen: CGFloat = 0
        var fBlue: CGFloat = 0
        var fAlpha: CGFloat = 0

        if self.getRed(&fRed, green: &fGreen, blue: &fBlue, alpha: &fAlpha) {

            var iRed = fRed * 255.0
            var iGreen = fGreen * 255.0
            var iBlue = fBlue * 255.0
            let iAlpha = fAlpha * 255.0

            switch alphaInfo {
            case .premultipliedLast:
                    iRed = (iRed / iAlpha) * 255
                    iGreen = (iGreen / iAlpha) * 255
                    iBlue = (iBlue / iAlpha) * 255
            default:
                break
            }

            return (red:UInt8(iRed.rounded()),   

                  green:UInt8(iGreen.rounded()),   

                   blue:UInt8(iBlue.rounded()), 

                  alpha:UInt8(iAlpha.rounded()))
        } else {
            // Could not extract RGBA components:
            return (0, 0, 0 , 0)
        }
    }
}

Fixed! Now it's working. After that is time to refactor these extensions to something better. For this post I end here. Thanks for reading.