Welcome back to the OpenCV series where we explore how to make use of OpenCV on Fedora Linux. The first article covered the basic functions and use cases of OpenCV. In addition to that you learned about loading images, color mapping, and the difference between BGR and RGB color maps. You also learned how to separate and merge color channels and how to convert to different color spaces. This article will cover basic image manipulation and show you how to perform image transformations including:

• Accessing individual image pixels
• Modifying a range of image pixels
• Cropping
• Resizing
• Flipping

Accessing individual pixels

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Read image as gray scale.
img = cv2.imread(cv2.samples.findFile("gradient.png"),0)
# Set color map to gray scale for proper rendering.
plt.imshow(img, cmap='gray')
# Print img pixels as 2D Numpy Array
print(img)
# Show image with Matplotlib
plt.show()

<figure class="aligncenter size-large"></figure>

To access a pixel in a numpy matrix, you have to use matrix notation such as matrix[r,c], where the r is the row number and c is the column number. Also note that the matrix is 0-indexed. If you want to access the first pixel, you need to specify matrix[0,0]. The following example prints one black pixel from top-left and one white pixel from top-right-corner.

# print the first pixel
print(img[0,0])
# print the white pixel to the top right corner
print(img[0,299])

Modifying a range of image pixels

You can modify the values of pixels using the same notation described above.

gr_img = img.copy()

# Modify pixel one by one
#gr_img[20,20] = 200
#gr_img[20,21] = 200
#gr_img[20,22] = 200
#gr_img[20,23] = 200
#gr_img[20,24] = 200
# ...

# Modify pixel between 20-80 pixel range
gr_img[20:80,20:80] = 200

plt.imshow(gr_img, cmap='gray')
print(gr_img)
plt.show()

<figure class="aligncenter size-large"></figure>

Cropping images

Cropping an image is achieved by selecting a specific (pixel) region of the image.

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread(cv.samples.findFile("starry_night.jpg"),cv.IMREAD_COLOR)
img_rgb = cv.cvtColor(img, cv.COLOR_BGR2RGB)
fig, (ax1, ax2) = plt.subplots(1,2)
ax1.imshow(img_rgb)
ax1.set_title('Before Crop')
ax2.imshow(img_rgb[200:400, 300:600])
ax2.set_title('After Crop')
plt.show()

<figure class="aligncenter size-large"></figure>

Resizing images

Syntax: dst = cv.resize( src, dsize[, dst[, fx[, fy[, interpolation]]]] )

The resize function resizes the src image down to or up to the specified size. The size and type are derived from the values of src, dsize,fx, and fy.

The resize function has two required arguments:

• src: input image
• dsize: output image size

Optional arguments that are often used include:

• fx: The scale factor along the horizontal axis. When this is 0, the factor is computed as dsize.width/src.cols.
• fy: The scale factor along the vertical axis. When this is 0, the factor is computed as dsize.height/src.rows.

import cv2 as cv
import matplotlib.pyplot as plt

img = cv.imread(cv.samples.findFile("starry_night.jpg"), cv.IMREAD_COLOR)
img_rgb = cv.cvtColor(img, cv.COLOR_BGR2RGB)

plt.figure(figsize=[18, 5])
plt.subplot(1, 3, 1)  # row 1, column 3, count 1

cropped_region = img_rgb[200:400, 300:600]
resized_img_5x = cv.resize(cropped_region, None, fx=5, fy=5)
plt.imshow(resized_img_5x)
plt.title("Resize Cropped Image with Scale 5X")

width = 200
height = 300
dimension = (width, height)
resized_img = cv.resize(img_rgb, dsize=dimension, interpolation=cv.INTER_AREA)

plt.subplot(1, 3, 2)
plt.imshow(resized_img)
plt.title("Resize Image with Custom Size")

desired_width = 500
aspect_ratio = desired_width / img_rgb.shape[1]
desired_height = int(resized_img.shape[0] * aspect_ratio)
dim = (desired_width, desired_height)
resized_cropped_region = cv.resize(img_rgb, dsize=dim, interpolation=cv.INTER_AREA)

plt.subplot(1, 3, 3)
plt.imshow(resized_cropped_region)
plt.title("Keep Aspect Ratio - Resize Image")
plt.show()

Flipping images

Syntax: dst = cv.flip( src, flipCode )

• dst: output array of the same size and type as src.

The flip function flips the array in one of three different ways.

The flip function has two required arguments:

• src: the input image
• flipCode: a flag to specify how to flip the image
  • Use 0 to flip the image on the x-axis.
  • Use a positive value (for example, 1) to flip the image on the y-axis.
  • Use a negative value (for example, -1) to flip the image on both axes.

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread(cv.samples.findFile("starry_night.jpg"),cv.IMREAD_COLOR)
img_rgb = cv.cvtColor(img, cv.COLOR_BGR2RGB)

img_rgb_flipped_horz = cv.flip(img_rgb, 1)
img_rgb_flipped_vert = cv.flip(img_rgb, 0)
img_rgb_flipped_both = cv.flip(img_rgb, -1)

plt.figure(figsize=[18,5])
plt.subplot(141);plt.imshow(img_rgb_flipped_horz);plt.title("Horizontal Flip");
plt.subplot(142);plt.imshow(img_rgb_flipped_vert);plt.title("Vertical Flip");
plt.subplot(143);plt.imshow(img_rgb_flipped_both);plt.title("Both Flipped");
plt.subplot(144);plt.imshow(img_rgb);plt.title("Original");
plt.show()

Further information

More details about OpenCV are available in the documentation.

Thank you.

Image editors are applications that are liked and needed by many people, from professional designers, students, or for those who have certain hobbies. Especially in this digital era, more and more people need image editors for various reasons. This article will introduce some of the open source image editors that you can use on Fedora Linux. You may need to install the software mentioned. If you are unfamiliar with how to add software packages in Fedora Linux, see my earlier article Things to do after installing Fedora 34 Workstation. Here is a list of a few apps for daily needs in the image editors category.

GIMP

GIMP (GNU Image Manipulation Program) is a raster graphics editor used for photo retouching, image composition, and image authoring. It has almost the same functionality as Adobe Photoshop. You can use GIMP to do a lot of the things you can do with Photoshop. Because of that, GIMP has become the most popular application as an open source alternative to Adobe Photoshop.

GIMP has a lot of features for manipulating images, especially for raster images. You can fix or change the color of your photos using GIMP. You can select a part of the image, crop it, and then merge it with other pieces of the image. GIMP also has many effects that you can apply to your images, including blur, shadow, noise, etc. Many people use GIMP to repair damaged photos, improve image quality, crop unwanted parts of images, create posters and various graphic design works, and much more. Moreover you can also add plugins and scripts in GIMP, making it even more fully featured.

More information is available at this link: https://www.gimp.org/

Inkscape

Inkscape is a popular open source application used to create and edit vector graphics. It is a feature-rich vector graphics editor which makes it competitive with other similar proprietary applications, such as Adobe Illustrator and Corel Draw. Because of that, many professional illustrators use it to create vector-based artwork.

You can use Inkscape for making artistic and technical illustrations, such as logos, diagrams, icons, desktop wallpapers, flowcharts, cartoons, and much more. Moreover, Inkscape can handle various graphic file formats. In addition, you can also add add-ons to make your work easier.

More information is available at this link: https://inkscape.org/

Krita

Krita looks like GIMP or Inkscape at first glance. But actually it is an application that is quite different, although it has some similar functions. Krita is an application for creating digital paintings like those made by artists. You can use Krita for making concept art, illustration, comics, texture, and matte paintings.

Krita has over 100 professionally made brushes that come preloaded. It also has a brush stabilizer feature with 3 different ways to smooth and stabilize your brush strokes. Moreover, you can customize your brushes with over 9 unique brush engines. Krita is the right application for those of you who like digital painting activities.

More information is available at this link: https://krita.org/en/

darktable

darktable is perfect for photographers or for those who want to improve the quality of their photos. darktable focuses more on image editing specifically on non-destructive post-production of raw images. Therefore, it provides professional color management that supports automatic display profile detection. In addition, you can also use darktable to handle multiple images with filtering and sorting features. So you can search your collections by tags, rating, color labels, and many more. It can import various image formats, such as JPEG, CR2, NEF, HDR, PFM, RAF, etc.

More information is available at this link: https://www.darktable.org/

Conclusion

This article presented four image editors as apps for your daily needs that you can use on Fedora Linux. Each application represents a sub-category of image editor applications. Actually there are many other image editors that you can use in Fedora Linux. You can also use RawTherapee or Photivo as a dartkable alternative. In addition there is Pinta as an alternative to GIMP, and MyPaint as an alternative to Krita. Hopefully this article can help you to choose the right image editors. If you have experience in using these applications, please share your experience in the comments.

The technology world changes daily and the demands for computer vision, artificial intelligence, and machine learning are increasing. The technology that allows computers and mobile phones to see their surroundings is called computer vision. Work on re-creating a human eye started in the 50s. Since then, computer vision technology has come a long way. Computer vision has already made its way to our mobile phones via different applications. This article will introduce OpenCV on Fedora Linux.

What is OpenCV?

OpenCV (Open Source Computer Vision Library) is an open-source computer vision and machine learning software library. OpenCV was built to provide a common infrastructure for computer vision applications and to accelerate the use of machine perception in the commercial products. It has more than 2500 optimized algorithms, which includes a comprehensive set of both classic and state-of-the-art computer vision and machine learning algorithms. These algorithms can be used to detect and recognize faces, identify objects, classify human actions in videos and establish markers to overlay it with augmented reality and much more.

opencv.org – about

Install OpenCV on Fedora Linux

To get started with OpenCV, install it from the Fedora Linux repositories.

$ sudo dnf install opencv opencv-contrib opencv-doc python3-opencv python3-matplotlib python3-numpy

Note: On Fedora Silverblue or CoreOs, Python 3.9 is part of the core commit. Layer OpenCV and required tools with: rpm-ostree install opencv opencv-doc python3-opencv python3-matplotlib python3-numpy.

Next, enter the following commands in a terminal to verify that OpenCV is installed (user input shown in bold).

$ python
Python 3.9.6 (default, Jul 16 2021, 00:00:00) 
[GCC 11.1.1 20210531 (Red Hat 11.1.1-3)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2 as cv
>>> print( cv.__version__ )
4.5.2
>>> exit()

The current OpenCV version should be displayed when you enter the print command as shown above. This indicates that OpenCV and the Python-OpenCV libraries have been installed successfully.

Additionally, if you want to take notes and write code with Jupyter Notebook and learn more about data science tools, check out the earlier Fedora Magazine article: Jupyter and Data Science in Fedora.

Get started with OpenCV

After installation is complete, load a sample image using Python and the OpenCV libraries (press the S key to save a copy of the image in png format and finish the program):

Contents of starry_night.py:

import cv2 as cv
import sys
img = cv.imread(cv.samples.findFile("starry_night.jpg"))
if img is None:
    sys.exit("Could not read the image.")
cv.imshow("Display window", img)
k = cv.waitKey(0)
if k == ord("s"):
    cv.imwrite("starry_night.png", img)

$ python starry_night.py

<figure class="aligncenter size-large is-resized"></figure>

Gray-scale the image by adding the parameter 0 to the cv.imread function as shown below.

img = cv.imread(cv.samples.findFile("starry_night.jpg"),0)

<figure class="aligncenter size-large is-resized"></figure>

These are some alternative values that can be used for the second parameter of the cv.imread function.

• cv2.IMREAD_GRAYSCALE or 0: Load the image in grayscale mode.
• cv2.IMREAD_COLOR or 1: Load the image in color mode. Any transparency in the image will be removed. This is the default.
• cv2.IMREAD_UNCHANGED or -1: Load the image unaltered; including alpha channel.

Display image attributes using OpenCV

Image attributes include the number of rows, columns, and channels; the type of image data; the number of pixels; etc. Suppose you wanted to access the image’s shape and its datatype. This is how you would do it:

import cv2 as cv

img = cv.imread(cv.samples.findFile("starry_night.jpg"))
print("Image size is", img.shape)
print("Data type of image is", img.dtype)

Image size is (600, 752, 3)
Data type of image is uint8

print(f"Image 2D numpy array \n {img}")

Image 2D numpy array 
 [[[0 0 0]
  [0 0 0]
  [0 0 0]
  ...
  [0 0 0]
  [0 0 0]
  [0 0 0]]

 [[0 0 0]
  [0 0 0]
  [0 0 0]
  ...

• img.shape: return a tuple of the number of rows, columns, and channels (if it is a color image)
• img.dtype: return the datatype of the image

Next display image with Matplotlib:

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread(cv.samples.findFile("starry_night.jpg"),0)
plt.imshow(img)
plt.show()

<figure class="aligncenter size-large is-resized"></figure>

What happened?

The image was read in as a gray-scale image, however it won’t necessarily display in gray-scale when using Matplotlib’s imshow fucntion. This is because the imshow function uses a different color map by default. To specify that a gray-scale color map should be used, set the second parameter of the imshow function to cmap=’gray’ as shown below.

plt.imshow(img,cmap='gray')

<figure class="aligncenter size-large is-resized"></figure>

This problem is also going to happen when opening a picture in color mode because Matplotlib expects the image in RGB (red, green, blue) format whereas OpenCV stores images in BGR (blue, green, red) format. For correct display, you need to reverse the channels of the BGR image.

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread(cv.samples.findFile("starry_night.jpg"),cv.IMREAD_COLOR)
fig, (ax1, ax2) = plt.subplots(1,2)
ax1.imshow(img)
ax1.set_title('BGR Colormap')
ax2.imshow(img[:,:,::-1])
ax2.set_title('Reversed BGR Colormap(RGB)')
plt.show()

<figure class="aligncenter size-large"></figure>

Splitting and merging color channels

import cv2 as cv
import matplotlib.pyplot as plt

img = cv.imread(cv.samples.findFile("starry_night.jpg"),cv.IMREAD_COLOR)
b,g,r = cv.split(img)

fig,ax = plt.subplots(2,2)

ax[0,0].imshow(r,cmap='gray')
ax[0,0].set_title("Red Channel");
ax[0,1].imshow(g,cmap='gray')
ax[0,1].set_title("Green Channel");
ax[1,0].imshow(b,cmap='gray')
ax[1,0].set_title("Blue Channel");

# Merge the individual channels into a BGR image
imgMerged = cv.merge((b,g,r))
# Show the merged output
ax[1,1].imshow(imgMerged[:,:,::-1])
ax[1,1].set_title("Merged Output");
plt.show()

<figure class="aligncenter size-large"></figure>

• cv2.split: Divide a multi-channel array into several single-channel arrays.
• cv2.merge: Merge several arrays to make a single multi-channel array. All the input matrices must have the same size.

Note: Images with more white have a higher density of color. Contrarily, images with more black have a lower density of color. In the above example the red color has the lowest density.

Converting to different color spaces

The cv2.cvtColor function converts an input image from one color space to another. When transforming between the RGB and BGR color spaces, the order of the channels should be specified explicitly (RGB2BGR or BGR2RGB). Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit blue component, the second byte will be green, and the third byte will be red. The fourth, fifth, and sixth bytes would then be the second pixel (blue, then green, then red), and so on.

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread(cv.samples.findFile("starry_night.jpg"),cv.IMREAD_COLOR)
img_rgb = cv.cvtColor(img, cv.COLOR_BGR2RGB)
plt.imshow(img_rgb)
plt.show()

<figure class="aligncenter size-large is-resized"></figure>

Further information

More details on OpenCV are available in the online documentation.

Thank you.

Copr is a collection of personal repositories for software that isn’t carried in Fedora Linux. Some software doesn’t conform to standards that allow easy packaging. Or it may not meet other Fedora Linux standards, despite being free and open-source. Copr can offer these projects outside the Fedora Linux set of packages. Software in Copr isn’t supported by Fedora infrastructure or signed by the project. However, it can be a neat way to try new or experimental software.

This article presents a few new and interesting projects in Copr. If you’re new to using Copr, see the Copr User Documentation for how to get started.

Wike

Wike is a Wikipedia reader for the GNOME Desktop with search integration in the GNOME Shell. It provides distraction-free access to the online encyclopedia. The interface is minimalistic but it supports switching an article between multiple languages, bookmarks, article table of contents, dark mode, and more.

Installation instructions

The repo currently provides Wike for Fedora 33, 34, and Fedora Rawhide. To install it, use these commands:

sudo dnf copr enable xfgusta/wike
sudo dnf install wike

DroidCam

We are living through confusing times, being isolated at our homes, and the majority of our interactions with friends and coworkers take place on some video conference platform. Don’t waste your money on an overpriced webcam if you carry one in your pocket already. DroidCam lets you pair your phone with a computer and use it as a dedicated webcam. The connection made through a USB cable or over WiFi. DroidCam provides remote control of the camera and allows zooming, using autofocus, toggling the LED light, and other convenient features.

Installation instructions

The repo currently provides DroidCam for Fedora 33 and 34. Before installing it, please update your system and reboot, or make sure you are running the latest kernel version and have an appropriate version of kernel-headers installed.

sudo dnf update
sudo reboot

Droidcam depends on v4l2loopback which must be installed manually from the RPM Fusion Free repository.

sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
sudo dnf install v4l2loopback
sudo modprobe v4l2loopback

Now install the droidcam package:

sudo dnf copr enable meeuw/droidcam
sudo dnf install droidcam

Nyxt

Nyxt is a keyboard-oriented, infinitely extensible web browser designed for power users. It was heavily inspired by Emacs and as such is implemented and configured in Common Lisp providing familiar key-bindings (Emacs, vi, CUA).

Other killer features that cannot be missed are a built-in REPL, tree history, buffers instead of tabs, and so much more.

Nyxt is web engine agnostic so don’t worry about pages rendering in unexpected ways.

Installation instructions

The repo currently provides Nyxt for Fedora 33, 34, and Fedora Rawhide. To install it, use these commands:

sudo dnf copr enable teervo/nyxt
sudo dnf install nyxt

Bottom

Bottom is a system monitor with a customizable interface and multitude of features, It took inspiration from gtop, gotop, and htop. As such, it supports processes monitoring, CPU, RAM, and network usage monitoring. Besides those, it also provides more exotic widgets such as disk capacity usage, temperature sensors, and battery usage.

Bottom utilizes the screen estate very efficiently thanks to the customizable layout of widgets as well as the possibility to focus on just one widget and maximizing it.

Installation instructions

The repo currently provides Bottom for Fedora 33, 34, and Fedora Rawhide. It is also available for EPEL 7 and 8. To install it, use these commands:

sudo dnf copr enable opuk/bottom
sudo dnf install bottom

Use btm command to run the program.

Maxima is an open source computer algebra system (CAS) with powerful symbolic, numerical, and graphical capabilities. You can perform matrix operations, differentiation, integration, solve ordinary differential equations as well as plot functions and data in two and three dimensions. As such, it is helpful for anyone interested in science and math. This article goes through installing and using Maxima in Fedora Linux.

Installing Maxima

Maxima is a command line system. You can install Maxima from the official Fedora repository using the following command:

sudo dnf install maxima

You can then use Maxima from the terminal by invoking the command maxima.

Installing wxMaxima

wxMaxima is a document based interface for Maxima. To install it in Fedora Linux, use the following command:

sudo dnf install wxmaxima

You can launch wxMaxima either by invoking the command wxmaxima in the terminal or clicking its application icon from the app grid or menu.

Basic Commands

After calling maxima, you should see terminal output as in the figure above.

The (%i1) is the input label where you enter the commands. Command in Maxima is an expression that can span over many lines and is closed with a semicolon (;). The o labels denote the outputs. Comments are enclosed between /* and */. You can use the special symbol percent (%) to refer to the immediately preceding result computed by Maxima. If you don’t want to print a result, you can finish your command with $ instead of ;. Here are basic arithmetic commands in Maxima:

 (%i1) (19 + 7)/(52 - 2 * 13);
 (%o1)                                  1
 (%i2) 127 / 5;
                                       127
 (%o2)                                 ---
                                        5
 (%i3) float (127 / 5); 
 (%o3)                                25.4
 (%i4) 127.0 / 5;     
 (%o4)                                25.4
 (%i5) sqrt(2.0);
 (%o5)                          1.414213562373095
 (%i6) sin(%pi/2);
 (%o6)                                 1
 (%i7) abs(-12);
 (%o7)                                12
 (%i8) 2+3*%i + 5 - 4*%i;             /*complex arithmetic*/
 (%o8)                              7 - %i

To end the Maxima session, type the command:

quit();

Algebra

Maxima can expand and factor polynomials:

(%i1) (x+y)^3 + (x+y)^2 + (x+y);
                                3          2
(%o1)                    (y + x)  + (y + x)  + y + x
(%i2) expand(%);
          3        2    2      2                  3    2
(%o2)    y  + 3 x y  + y  + 3 x  y + 2 x y + y + x  + x  + x
(%i3) factor(%);
                          2                2
(%o3)           (y + x) (y  + 2 x y + y + x  + x + 1)

To substitute y with z and x with 5, refer the output label above and use the following command:

(%i4) %o3, y=z, x=5;
                                    2
(%o4)                     (z + 5) (z  + 11 z + 31)

You can easily manipulate trigonometric identities:

(%i1) sin(x) * cos(x+y)^2;
                                       2
(%o1)                        sin(x) cos (y + x)
(%i2) trigexpand(%);
                                                         2
(%o2)              sin(x) (cos(x) cos(y) - sin(x) sin(y))
(%i3) trigreduce(%o1);
                   sin(2 y + 3 x) - sin(2 y + x)   sin(x)
(%o3)              ----------------------------- + ------
                                 4                   2

You can also solve algebraic equations in one or more variables:

(%i1) solve(x^2+5*x+6);
 (%o1)                         [x = - 3, x = - 2]
(%i2) solve(x^3 + 1);
                  sqrt(3) %i - 1      sqrt(3) %i + 1
 (%o2)     [x = - --------------, x = --------------, x = - 1]
                        2                   2
(%i3) eqns: [x^2 + y^2 = 9, x + y = 3];
                              2    2
 (%o3)                      [y  + x  = 9, y + x = 3]
 (%i4) solve(eqns, [x,y]);
 (%o4)                 [[x = 3, y = 0], [x = 0, y = 3]]

Calculus

Define f to be a function of x. You can then find the limit, derivative and integral of the function:

(%i1) f: x^2;
                                       2
 (%o1)                                x
 (%i2) limit(f,x,0);
 (%o2)                                  0
 (%i3) limit(1/f,x,0);
 (%o3)                                 inf
 (%i4) diff(f, x);
 (%o4)                                2 x
 (%i5) integrate(f, x);
                                       3
                                      x
 (%o5)                                --
                                      3

To find definite integrals, slightly modify the syntax above.

 (%i6) integrate(f, x, 1, inf);
 defint: integral is divergent.
  -- an error. To debug this try: debugmode(true);
 (%i7) integrate(1/f, x, 1, inf);
 (%o7)                                 1

Maxima can perform Taylor expansion. Here’s the Taylor expansion of sin(x) up to order 5 terms.

(%i1) taylor(sin(x), x, 0, 5);
                                   3    5
                                  x    x
 (%o1)/T/                     x - -- + --- + . . .
                                  6    120

To represent derivatives in unevaluated form, use the following syntax.

(%i2) 'diff(y,x);
                                       dy
 (%o2)                                 --
                                       dx

The ode2 function can solve first and second order ordinary differential equations (ODEs).

(%i1) 'diff(y,x,2) + y = 0;
                                    2
                                   d y
 (%o1)                             --- + y = 0
                                     2
                                   dx
 (%i2) ode2(%o1,y,x);
 (%o2)                     y = %k1 sin(x) + %k2 cos(x)

Matrix Operations

To enter a matrix, use the entermatrix function. Here’s an example of a general 2×2 matrix.

(%i1) A: entermatrix(2,2);
 Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
 Answer 1, 2, 3 or 4 : 
 4;
 Row 1 Column 1: 
 1;
 Row 1 Column 2: 
 2;
 Row 2 Column 1: 
 3;
 Row 2 Column 2: 
 4;
 Matrix entered.
                                    [ 1  2 ]
 (%o1)                              [      ]
                                    [ 3  4 ]

You can then find the determinant, transpose, inverse, eigenvalues and eigenvectors of the matrix.

(%i2) determinant(A);
 (%o2)                                 - 2
 (%i3) transpose(A);
                                    [ 1  3 ]
 (%o3)                              [      ]
                                    [ 2  4 ]
(%i4) invert(A);
                                  [ - 2   1  ]
                                  [          ]
 (%o4)                            [  3     1 ]
                                  [  -   - - ]
                                  [  2     2 ]
(%i5) eigenvectors(A);
            sqrt(33) - 5  sqrt(33) + 5
 (%o5) [[[- ------------, ------------], [1, 1]], 
                 2             2
               sqrt(33) - 3         sqrt(33) + 3
       [[[1, - ------------]], [[1, ------------]]]]
                    4                    4

In the output label (%o5) the first array gives the eigenvalues, the second array gives the multiplicity of the respective eigenvalues, and the next two arrays give the corresponding eigenvectors of the matrix A.

Plotting

Maxima can use either Gnuplot, Xmaxima or Geomview as graphics program. Maxima package in Fedora Linux comes with gnuplot as a dependency, so Maxima uses gnuplot_pipes as the plotting format. To check the plotting format, use the following command inside Maxima.

get_plot_option(plot_format);

Below are some plotting examples.

(%i1) plot2d([sin(x), cos(x)], [x, -2*%pi, 2*%pi]);

(%i2) plot3d(sin(sqrt(x^2+y^2)), [x, -7, 7], [y, -7, 7]);

(%i3) mandelbrot ([iterations, 30], [x, -2, 1], [y, -1.2, 1.2],
             [grid,400,400]);

You can read more about Maxima and its capabilities in its official website and documentation.

Fedora Linux has plethora of tools for scientific use. You can find the widely used ones in the Fedora Scientific Guide.

Linux distributions are great to use and they have some tricks under their sleeves which users may not be aware of. Let’s have a look at some command line utilities which really come in handy when you’re the guy that likes to stick with the terminal rather than using a GUI. 

We all know that using a terminal is more efficient to use the system. In case you are editing or playing with text files on a terminal then these tools will surely make your life easy.

For this article let’s have a look at wc, sort, tr, and sed commands.

wc

wc is a utility whose name stands for “word count”. As the name suggests it will count the lines, words or byte count from any file. 

Let’s see how it works:

$ wc filename
lines words characters filename

So in output we get the total number of newlines in the file, total number of words, total number of characters, and the filename.

To get some specific output we have to use options:

• -c To print the byte counts
• -l   To print the newline counts
• -w To print the word counts
• -m To print the character counts

wc demo

Let’s see it in action:

Here we start with a text file, loremipsm.txt. First, we print out the file and then use wc on it.

$ cat loremipsm.txt
Linux is the best-known and most-used open source operating system.
As an operating system, Linux is software that sits underneath all of the other software on a computer,
receiving requests from those programs and replaying these requests to the computer's hardware.

$ wc loremipsm.txt
3 41 268 loremipsm.txt

Suppose I only want to see the byte count of the file: 

$ wc -c loremipsm.txt
268 loremipsm.txt

For the newline count of the file:

$ wc -l loremipsm.txt
3 loremipsm.txt

To see the word count of the file:

$ wc -w loremipsm.txt
41 loremipsm.txt

Now only the character count of the file:

$ wc -m loremipsm.txt
268 loremipsm.txt

sort

The sort command is one of the most useful tools. It will sort the data in a file. Sorting is by either characters or numbers in ascending or descending order. It can also be used to sort or randomize the lines of files.

Using sort can be very simple.  All we need to do is provide the name of the file.

$ sort filename

By default it sorts the data in alphabetical order. One thing to note is that the sort command just displays the sorted data. It does not overwrite the file.

Some useful options for sort: 

• -r  To sort the lines in the file in reverse order
• -R To shuffle the lines in the file into random order
• -o To save the output in another file
• -k To sort as per specific column
• -t To mention the field separator
• -n To sort the data according to numerical value

sort demo

Let’s use sort in some short demos:

We have a file, list.txt, containing names and numeric values separated by commas.

First let’s print out the file and just do simple sorting.

$ cat list.txt
Cieran Wilks, 9
Adelina Rowland, 4
Hayden Mcfarlnd, 1
Ananya Lamb, 5
Shyam Head, 2
Lauryn Fuents, 8
Kristian Felix, 10
Ruden Dyer, 3
Greyson Meyers, 6
Luther Cooke, 7

$ sort list.txt
Adelina Rowland, 4
Ananya Lamb, 5
Cieran Wilks, 9
Greyson Meyers, 6
Hayden Mcfarlnd, 1
Kristian Felix, 10
Lauryn Fuents, 8
Luther Cooke, 7
Ruden Dyer, 3
Shyam Head, 2

Now sort the data in the reverse order.

$ sort -r list.txt
Shyam Head, 2
Ruden Dyer, 3
Luther Cooke, 7
Lauryn Fuents, 8
Kristian Felix, 10
Hayden Mcfarlnd, 1
Greyson Meyers, 6
Cieran Wilks, 9
Ananya Lamb, 5
Adelina Rowland, 4

Let’s shuffle the data.

$ sort -R list.txt
Cieran Wilks, 9
Greyson Meyers, 6
Adelina Rowland, 4
Kristian Felix, 10
Luther Cooke, 7
Ruden Dyer, 3
Lauryn Fuents, 8
Hayden Mcfarlnd, 1
Ananya Lamb, 5
Shyam Head, 2

Let’s make it more complex. This time we sort the data according to the second field, which is the numeric value, and save the output in another file using the -o option.

$ sort -n -k2 -t ',' -o sorted_list.txt list.txt
$ ls 
   sorted_list.txt    list.txt
$ cat sorted_list.txt
Hayden Mcfarlnd, 1
Shyam Head, 2
Ruden Dyer, 3
Adelina Rowland, 4
Ananya Lamb, 5
Greyson Meyers, 6
Luther Cooke, 7
Lauryn Fuents, 8
Cieran Wilks, 9
Kristian Felix, 10

Here we used -n to sort in numerical order, -k to specify the field to sort (2 in this case) -t to indicate the delimiter or field-separator (a comma) and -o to save the output in the file sorted_list.txt. 

sed

Sed is a stream editor that will filter and transform text in the output. This means we are not making changes in the file, only to the output. We can also save the changes in a new file if needed. Sed comes with a lot of options that are useful in filtering or editing the data. 

The syntax for sed is:

$ sed [OPTION] ‘PATTERN’ filename

Some of the options used with sed:

• -n : To suppress the printing 
• p: To print the current pattern 
• d : To delete the pattern 
• q : To quit the sed script

sed demo

Lets see sed in action. We start with the file data with the fields indicating number, name, age and operating system.

Printing the lines twice if they occur in a specific range of lines.

$ cat data
1    Vicky Grant      20   linux
2    Nora Burton    19   Mac
3    Willis Castillo   21  Windows
4    Gilberto Mack 30   Windows
5    Aubrey Hayes  17   windows
6    Allan Snyder    21   mac
7    Freddie Dean   25   linux
8    Ralph Martin    19   linux
9    Mindy Howard  20   Mac

$ sed '3,7 p' data
1    Vicky Grant      20   linux
2    Nora Burton    19   Mac
3    Willis Castillo   21  Windows
3    Willis Castillo   21  Windows
4    Gilberto Mack 30   Windows
4    Gilberto Mack 30   Windows
5    Aubrey Hayes  17   windows
5    Aubrey Hayes  17   windows
6    Allan Snyder    21   mac
6    Allan Snyder    21   mac
7    Freddie Dean   25   linux
7    Freddie Dean   25   linux
8    Ralph Martin    19   linux
9    Mindy Howard 20   Mac

Here the operation is specified in single quotes indicating lines 3 through 7 and using ‘p’ to print the pattern found. The default behavior of sed is to print every line after parsing it. This means lines 3 through 7 appear twice because of the ‘p’ instruction.

So how can you print specific lines from the file? Use the ‘-n’ option to eliminate lines that do not match from the output.

$ sed -n '3,7 p' data
3    Willis Castillo     21    Windows
4    Gilberto Mack    30   Windows
5    Aubrey Hayes     17   windows
6    Allan Snyder       21   mac
7    Freddie Dean      25  linux

Only lines 3 through 7 will appear using ‘-n’ .

Omitting specific lines from the file. This uses the ‘d’ to delete the lines from the output.

$ sed '3 d' data
1    Vicky Grant      20    linux
2   Nora Burton     19    Mac
4   Gilberto Mack  30    Windows
5   Aubrey Hayes   17    windows
6   Allan Snyder     21    mac
7   Freddie Dean    25   linux
8   Ralph Martin    19    linux
9   Mindy Howard  20   Mac

$ sed '5,9 d' data
1    Vicky Grant     20   linux
2   Nora Burton    19   Mac
3   Willis Castillo   21   Windows
4   Gilberto Mack 30   Windows

Searching for a specific keyword in the file.

$ sed -n '/linux/ p' data
7    Freddie Dean   25  linux
8    Ralph Martin   19   linux

$ sed -n '/linux/I p' data
1     Vicky Grant      20  Linux
7     Freddie Dean  25  linux
8     Ralph Martin   19  linux

In these examples we have a regular expression which appears in ‘/ /’. If we have similar words in the file but not with proper case then we use the “I” to make the search case insensitive. Recall that the -n eliminates the lines that do not match from the output.

Replacing the words in the file.

$ sed 's/linux/linus/' data
1   Vicky Grant      20   Linux
2   Nora Burton    19   Mac
3   Willis Castillo   21   Windows
4   Gilberto Mack  30  Windows
5   Aubrey Hayes   17  windows
6   Allan Snyder     21  mac
7   Freddie Dean    25 linus
8   Ralph Martin    19  linus
9   Mindy Howard 20  Mac

Here ‘s/ / /’ denotes that it is a regex. The located word and then the new word to replace it appear between the two ‘/’.

tr

The tr command will translate or delete characters. It can transform the lowercase letters to uppercase or vice versa, eliminate repeating characters, and delete specific characters.

One thing weird about tr is that it does not take files as input like wc, sort and sed do. We use “|” (the pipe symbol) to provide input to the tr command.

$ cat filename | tr [OPTION]

Some options used with tr:

• -d : To delete the characters in first set of output
• -s : To replace the repeated characters with single occurrence

tr demo

Now let’s use the tr command with the file letter to convert all the characters from lowercase to uppercase.

$ cat letter
Linux is too easy to learn,
And you should try it too.

$ cat letter | tr 'a-z' 'A-Z'
LINUX IS TOO EASY TO LEARN,
AND YOU SHOULD TRY IT TOO.

Here ‘a-z’ ‘A-Z’ denotes that we want to convert characters in the range from “a” to “z” from lowercase to uppercase.

Deleting the “o” character  from the file.

$ cat letter | tr -d 'o'
Linux is t easy t learn,
And yu shuld try it t.

Squeezing the character “o” from the file means that if “o” is repeated in line then it will remove it and print it only once. 

$ cat letter | tr -s 'o'
Linux is to easy to learn,
And you should try it to.

Conclusion

This was a quick demonstration of the wc, sort, sed and tr commands. These commands make it easy to manipulate the text files on the terminal in a quick and efficient way. You may use the man command to learn more about these commands.

GitHub Actions is a service provided to quickly setup continuous integration and delivery (CI/CD) workflows . These workflows run on hosts called runners. GitHub provides hosted runners with a limited set of operating system choice (Windows Server, Ubuntu, MacOS).

Another option is to use self-hosted runners which gives the repository administrator more control on the runners. Self-hosted runners are dedicated to a repository or organization. The following article goes through the steps of configuring self-hosted runners using Fedora CoreOS.

Getting Started

Fedora CoreOS is a minimalist operating system designed to be easy to deploy and maintain at scale. The operating system will automaticaly update and provide, by default, the tools needed to run containers. For all of these reasons, Fedora CoreOS is a great choice to consider for running CI/CD workflows.

The first step to configure and provision a Fedora CoreOS machine is to generate an Ignition file. Butane allows you to generate Ignition’s file using a friendlier format (YAML).

Configure a Fedora CoreOS runner

To execute GitHub actions on Fedora CoreOS, the host needs the binaries and scripts used to register and run the runner. Download the binaries and scripts from the actions runner project and deploy under /usr/local/sbin/actions-runner.

version: "1.3.0"
variant: fcos
storage:
  directories:
    - path: /usr/local/sbin/actions-runner
      mode: 0755
      user:
        name: core
      group:
        name: core
  files:
    - path: /usr/local/sbin/actions-runner/actions-runner-linux.tar.gz
      overwrite: true
      contents:
        source: https://github.com/actions/runner/releases/download/v2.278.0/actions-runner-linux-x64-2.278.0.tar.gz
      mode: 0755
      user:
        name: core
      group:
        name: core

Registration and Removal token

Configuring runners for a project requires a “token”. This prevents registering or removing self-hosted runners from projects without the correct permissions. Tokens provided by Github have a one hour expiration time. If the runner restarts after this time it will require a new registration token.

The token can be problematic, in particular with Fedora CoreOS automatic updates. The update process expects that the host will restart at least once every couple weeks after receiving new data.

Luckily, it is possible to use GitHub REST API to obtain these tokens and automatically configure the runner every time the host restarts. The following manage-runner.sh script uses the APIs to retrieve a token, remove any runner already configured and register the runner with a new token.

#!/bin/bash
# Handles the Github Action runner configuration.
# Remove and Registration token expires after 1 hour, if we want our runner
# to work after a reboot (auto update) we need to refresh the tokens.

# First remove the runner with a fresh remove token
REMOVE_TOKEN=$(curl -u ${GITHUB_USER}:${GITHUB_TOKEN} -X POST -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/${GITHUB_USER}/${GITHUB_REPO}/actions/runners/remove-token | jq -r '.token')
/usr/local/sbin/actions-runner/config.sh remove --token ${REMOVE_TOKEN}


# Then register the runner with a fresh registration token
REGISTRATION_TOKEN=$(curl -u ${GITHUB_USER}:${GITHUB_TOKEN} -X POST -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/${GITHUB_USER}/${GITHUB_REPO}/actions/runners/registration-token | jq -r '.token')
/usr/local/sbin/actions-runner/config.sh --url https://github.com/cverna/fcos-actions-runner --token ${REGISTRATION_TOKEN} --labels fcos --unattended

The script above uses a few environment variables that contain a GitHub username and a Personal Access Token used to authenticate the REST API requests. The Personal Access Token requires the repo permissions in order to successfully retrieve the runner registration and removal tokens. The token is security sensitive so it is better to store it in a different file with stricter permissions. In this example that file is actions-runner.

GITHUB_USER=<user>
GITHUB_REPO=<repo>
GITHUB_TOKEN=<personal_access_token> 

Following is the Butane snippet that creates these two files – manage-runner.sh and actions-runner.

    - path: /usr/local/sbin/actions-runner/manage-runner.sh
      contents:
        local: manage-runner.sh
      mode: 0755
      user:
        name: core
      group:
        name: core
    - path: /etc/actions-runner
      contents:
        local: actions-runner
      mode: 0700
      user:
        name: core
      group:
        name: core

Running Actions on Fedora CoreOS

Finally, create the systemd services that will configure and start the runner. Define the services in the Butane configuration file.

systemd:
  units:
    - name: github-runner-configure.service
      enabled: true
      contents: |
        [Unit]
        Description=Configure the github action runner for a repository
        After=network-online.target boot-complete.target
        Requires=boot-complete.target
        [Service]
        EnvironmentFile=/etc/actions-runner
        Type=oneshot
        RemainAfterExit=yes
        User=core
        WorkingDirectory=/usr/local/sbin/actions-runner
        ExecStartPre=tar xvf actions-runner-linux.tar.gz --no-same-owner
        ExecStart=/usr/local/sbin/actions-runner/manage-runner.sh
        [Install]
        WantedBy=multi-user.target
    - name: github-runner.service
      enabled: true
      contents: |
        [Unit]
        Description=Run the github action runner
        After=github-runner-configure.service
        [Service]
        WorkingDirectory=/usr/local/sbin/actions-runner
        User=core
        ExecStart=/usr/local/sbin/actions-runner/run.sh
        [Install]
        WantedBy=multi-user.target

This creates two services, github-runner-configure.service (running once when the host has finished booting) and github-runner.service (running the Actions runner binaries and waiting for new CI/CD jobs).

Now that the Butane configuration is complete, generate an Ignition file out of it and provision a Fedora CoreOS Actions runner.

$ podman run -i --rm -v $PWD:/code:z --workdir /code quay.io/coreos/butane:release --pretty --strict --files-dir /code config.yaml -o config.ignition

Once the Ignition file is generated, it can be used to provision a runner on the platforms where Fedora CoreOS is available.

Configure an Action to use a self-hosted runner

The following test Action workflow will test the FCOS self-hosted worker. Create the following file in your git repository .github/workflows/main.yml

# This is a basic workflow to help you get started with Actions

name: CI

# Controls when the action will run. 
on:
  # Triggers the workflow on push or pull request events but only for the main branch
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job will run on
    runs-on: fcos

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # Runs a single command using the runners shell
      - name: Run a one-line script
        run: podman run --rm fedora-minimal:34 echo Hello World !

Note that the runs-on configuration is set up to use a runner with the label fcos.

The code presented in this article is available here.