Forem: Christopher Konopka

Create an RGBA histogram of a cat using Imagemagick

Christopher Konopka — Thu, 16 Jan 2020 19:47:28 +0000

How do I create a histogram of this cat image?

Create a new bash script named create-histogram.sh.

# create-histogram.sh
#!/bin/bash

Provide a ".png" file

echo "PNG please ~~~~~"
read PNG

Remove ".png" from PNG

SPLICE=${PNG%????}

Create the EXPORTFILE as ".txt"

EXPORTFILE="${SPLICE}.txt"
echo $EXPORTFILE

Export a histogram ".txt" file based on the ".png"

convert $PNG -format %c histogram:info:- > $EXPORTFILE

The exported histogram will look something like this ...

And a here is a clip of the workflow.

Configuring environmental variables for Go with ~/.bash_profile

Christopher Konopka — Wed, 15 Jan 2020 21:57:54 +0000

Before sharing a project that uses credentials, it is important to show a user how to save their credentials within the bash_profile. The reasoning for this is security, and it makes variables globally accessible within the architecture. The example is specifically for OSX and Linux.

Open the ~/.bash_profile using your favorite text editor using Terminal.

nano ~/.bash_profile

Create a new variable and export it. Save and exit.

export API_KEY="KEY"
export API_SECRET="SECRET"

Reload the variables using source.

source ~/.bash_profile

Create a new Go program and name it main.js. Add the fmt and os libraries.

package main

import(
  "fmt"
  "os"
)

func main(){
    // ... code here
}

Use the os library's Getenv function to retrieve the environmental variable and print them out.

APIkey := os.Getenv("API_KEY")
APIsecret := os.Getenv("API_SECRET")

Print out the APIkey and APIsecret using fmt.

fmt.Println(APIkey, APIsecret)

Generate GIFs from a directory of videos using FFmpeg

Christopher Konopka — Thu, 09 Jan 2020 18:56:11 +0000

Background

As a video artist I deal with many physical formats (analog composite to 4K) and digital formats (.mp4, .mov, Motion JPEG, .gif, etc.). Going between formats can be a nightmare, and I like to build tools that can ease any potential stress. Over the summer, I wanted to convert my analog video synthesis into .gif files to upload to Giphy. So I made this bash script that ingests a directory of video content and asks for a target file format.

Breakdown

Create a new bash script named dir-gen-gif.sh.

# dir-gen-gif.sh
#!/bin/bash

Ask for a directory of video content.

echo "Provide a directory please :"
read dir

Ask for a video file format.

echo "Filetype?"
read filetype

Create a loop that iterates over the directory and finds the target video file format.

for f in $dir/*.$filetype
do
    echo "Processing $f"
    # ... ffmpeg code
done

Add the FFmpeg scripts. First create a .png analysis file and then generate a .gif file.

    # Generate .png analysis file
    ffmpeg -y -ss 0 -t 11 -i $f -filter_complex "[0:v] palettegen" "${f%.*}.png"
    # Create .gif file
    ffmpeg -ss 0 -t 11 -i $f -filter_complex "[0:v] fps=24,scale=w=480:h=-1,split [a][b];[a] palettegen=stats_mode=single [p];[b][p] paletteuse=new=1" "${f%.*}.gif"

And the process will look something like this ...

Reference

# dir-gen-gif.sh
#!/bin/bash

# Provide a directory containing video files 
echo "Provide a directory please :"
read dir

# Filetype target
echo "Filetype?"
read filetype

# Iterate over the directory, look for target filetype
for f in $dir/*.$filetype
do
    echo "Processing $f"
    # Generate .png analysis file
    ffmpeg -y -ss 0 -t 11 -i $f -filter_complex "[0:v] palettegen" "${f%.*}.png"
    # Create .gif file
    ffmpeg -ss 0 -t 11 -i $f -filter_complex "[0:v] fps=24,scale=w=480:h=-1,split [a][b];[a] palettegen=stats_mode=single [p];[b][p] paletteuse=new=1" "${f%.*}.gif"
done

Get daily earthquake data from the USGS using Go

Christopher Konopka — Tue, 07 Jan 2020 21:31:14 +0000

Recently I started an earthquake sonification project and the first step is acquiring daily earthquake magnitudes from the USGS.

Use the USGS URL below, open a browser and go to the following link. Note the starttime and endtime determine the date range of the results.

https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=2014-01-01&endtime=2014-01-02

A large JSON response is returned, but for the purposes of the post a shorter version is provided. The goal is to access the Place and Magnitude values from the properties object inside the features object.

{
    "type": "FeatureCollection",
    "metadata": {
        "generated": 1578386362000,
        "url": "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=2014-01-01&endtime=2014-01-02",
        "title": "USGS Earthquakes",
        "status": 200,
        "api": "1.8.1",
        "count": 324
    },
    "features": [{
        "type": "Feature",
        "properties": {
            "mag": 1.29,
            "place": "10km SSW of Idyllwild, CA",
            "time": 1388620296020,
            "updated": 1457728844428,
            "tz": -480,
            "url": "https://earthquake.usgs.gov/earthquakes/eventpage/ci11408890",
            "detail": "https://earthquake.usgs.gov/fdsnws/event/1/query?eventid=ci11408890&format=geojson",
            "felt": null,
            "cdi": null,
            "mmi": null,
            "alert": null,
            "status": "reviewed",
            "tsunami": 0,
            "sig": 26,
            "net": "ci",
            "code": "11408890",
            "ids": ",ci11408890,",
            "sources": ",ci,",
            "types": ",cap,focal-mechanism,general-link,geoserve,nearby-cities,origin,phase-data,scitech-link,",
            "nst": 39,
            "dmin": 0.067290000000000003,
            "rms": 0.089999999999999997,
            "gap": 51,
            "magType": "ml",
            "type": "earthquake",
            "title": "M 1.3 - 10km SSW of Idyllwild, CA"
        },
        "geometry": {
            "type": "Point",
            "coordinates": [-116.7776667, 33.663333299999998, 11.007999999999999]
        },
        "id": "ci11408890"
    }]
}

Use JSON-to-Struct to create a struct from the JSON response. A modified version is added below that focuses on the earthquake's Place and Magnitude.

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

type usgsJSON struct {
    Features []feature `json:"features"`
}

type feature struct {
    Properties Earthquake `json:"properties"`
}

type Earthquake struct {
    Place     string  `json:"place"`
    Magnitude float64 `json:"mag"`
}

func main(){
     // insert code here
}

Get the current date.

current := time.Now()
currentFormat := current.Format("2006-01-02")

Get yesterdays date.

yesterdayTime := time.Now().Add(-24 * time.Hour)
yesterFormat := yesterdayTime.Format(("2006-01-02"))

Construct the USGS URL for the GET request using the currentFormat and yesterFormat.

findHawaiianVolcanos := "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=" + yesterFormat + "&endtime=" + currentFormat

Perform a GET request.

resp, err := http.Get(findHawaiianVolcanos)
if err != nil {}

Read the data until EOF and return the data to the body variable.

body, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()

Unmarshal the body into usgsJSON struct.

var record usgsJSON
json.Unmarshal(body, &record)

Make a slice of "Earthquake" of length 0.

quakes := make([]Earthquake, 0)

Iterate over each "features" object and append the "properties" object to the quakes slice.

for _, f := range record.Features {
    quakes = append(quakes, f.Properties)
}

Iterate over the length of quakes and print out the magnitudes and location.

for q := 0; q < len(quakes); q++ {
    fmt.Print(quakes[q].Place + " ")
    fmt.Println(quakes[q].Magnitude)
}

Build the program.

go build usgs-dailyearthquakes.go

List the earthquakes