Audio Steganography : The art of hiding secrets within earshot (part 1 of 2)

Audio Steganography Methods

In this article, we will take a look at some of the popular methods to embed “secret” text, images and audios inside a “public” sound file. Our purpose is to enable a sender to secretly send their data, hidden within a song.

LSB (Least Significant Bit) Algorithm

LSB algorithm is a classic Steganography method used to conceal the existence of secret data inside a “public” cover. The LSB or “Least Significant Bit”, in computing terms, represents the bit at the unit’s place in the binary representation of a number.

For example, we can represent the decimal number 170 in binary notation as 10101010 (we assume little-endian machine with address starting from the right and increasing towards left). As shown in the figure, the least significant bit, in this case, is 0.

In the simplistic form, LSB algorithm replaces the LSB of each byte in the “carrier” data with one bit from the “secret” message. This concept is visualized in the diagram below.

The sender performs “embedding” of the bits of secret messages onto the carrier data byte-by-byte. Whereas the receiver performs the “extraction” procedure by reading LSB bits of each byte of received data, this way the receiver reconstructs the secret message.

Isn’t this corrupting the carrier signal?

Yes, but the main idea here is that we are trying to exploit the human perception of the integrity of the carrier signal. LSB steganography is very popular for Image Steganography, i.e. hiding secrets in images. And the change in LSB affects the color just so slightly that the change in color is not generally perceptible to the human eye. However, the human ear is more sensitive to slights changes in sound and hence the “noise” that we are adding would have a higher chance of being noticed. To overcome this problem of this trivial form of LSB algorithm, many researchers have suggested variants that increase robustness in the audio domain.

LSB algorithm implementation in Python

Let’s implement this method with some sound data as our carrier signal that would carry our secret text. As our sound data, I am taking a sample from a song by Indian electronic music producer Udyan Sagar’s (better known as Nucleya). This song will be the carrier of our secret text message, “Peter Parker is the Spiderman!”.

The underlying bit manipulation in LSB is pretty straightforward. We will perform logical AND operation between each byte of carrier audio (the “song”) and a bit mask that resets the LSB of carrier byte.

Then we will perform a simple logical OR operation between the modified carrier byte and the next bit (0 or 1) from the secret message.

We will use .wav audio file format for our carrier song. Wave is one of the most popular lossless compression format. Python has a native library called “wave” that provides us basic tools to manipulate audio data.

Below code is used by the sender to embed the secret text message. The code is sufficiently commented to explain the process step-by-step.

As the output of the above code, we get the below audio file that has the secret text embedded in it. There is some noticeable noise in this audio file. As an experiment, you could try and embed every 2nd or 3rd byte of carrier audio with one bit from the secret, and see if that fetches a more robust result.

To extract the secret from this audio, the receiver shall run the below Python code.

Among other popular techniques for Audio Steganography are Phase Coding, Echo Hiding, and Spread Spectrum. These classic techniques do not induce noise in the carrier signal and hence are more robust methods for achieving Steganography. I encourage you to read related literature if you want to study them in more details or let me know in the comments if you would like me to write on these methods.

A note on SSTV

As you can image, we can embed any text, document, audio, video within the carrier audio by simply encoding bits of the secret data within each byte of carrier audio. However, the carrier message has to have enough data bytes so as to carry all the bits of the secret message. In the next section, we will take a look at a frequency modulation based method to hide secret data in the inaudible frequency range. But before that I would like to talk about a method that you can use to encode your image data to audio and then use the Steganography method described in the next section to embed and extract the image from the carrier audio.

SSTV is an acronym for Slow-Scan Television, which is a very popular method in radio transmission to send image data over a long distance via ionoshperic propagation. SSTV enables transmission of images in places where very little bandwidth is available, for example, over the Plain Old Telephone Service(POTS) line. In fact, Apollo 11 moon mission had used SSTV to transmit images back to earth.

SSTV is based on analog frequency modulation, that looks at the brightness of each pixel and the accordingly allocates a different audio frequency for it. Usually, SSTV is used to transfer greyscale images, we can also use it to transfer colored images with some loss in image resolution.

Amateur-Radio wiki has a list of some of the available SSTV software on different platforms. András Szentkirályi has made a Python package called PySSTV that generates SSTV modulated wave file for image files. You can use pip to install this package.

pip install pysstv 

After installing the package, you can run below command to convert an image file (image.jpg) to SSTV modulated audio (audio.wav) file.

python -m pysstv /path/to/image.jpg /path/to/audio.wav

This package also has the implementation for different SSTV modes including the popular Martin, Robot, and Scottie. You can specify the modes and other parameters while converting the image.

Now you can play this audio on your computer using any media player and that is all you need to do at the sender end. To receive this audio, I would recommend installing some application on your mobile phone that can extract the image back by listening to our “audio.wav” through the phone’s mic. One such Android app is the Robot36 on play store.

Robot36 - SSTV Image Decoder - Apps on Google Play

As an example, I encoded below image using PySSTV and got the given encoded audio.

The resulting audio is not pleasant on the ear, but you can modulate it to the inaudible range and have it transferred covertly within a “public” audio.

In the below video I have given a demonstration of encoding and decoding an image by transferring it as SSTV modulated audio.

[Video to be added soon.]

Frequency Modulation based Steganography

The Frequency-modulation based method that we are going to discuss here is very powerful and doesn’t induce noise in the carrier signal. Using this method we will embed one “secret” audio onto another “public” audio. The secret audio shall be imperceptible to the human ear and the receiver would be able to extract the secret audio at their end.

The main idea of this algorithm is that we will conceal our secret audio in the near-ultrasound range while keeping our public audio data in the normal hearing range. As explained in the previous installment of this post, the near-ultrasound audio will be inaudible to most humans above a certain age. You can decide what frequency modulation frequency to use, based on the age and even gender of your target.

To modulate the secret audio onto the inaudible range, we will use the method described by Lowery Oliver M, in below patent.

US5159703A - Silent subliminal presentation system - Google Patents

We will use near-ultrasound frequencies to encode the secret rather than infrasounds because as we saw in the last post, long exposure to infrasounds can be harmful, whereas there is no scientific evidence of any harm being induced to human ear by small exposure to near-hypersounds.

We can use the method described above to make a demonstration on a regular sound card present on most computers with support for 44.1 kHz sampling rate. Audacity user, edgar-rft, has provided one implementation of the method in above patent in Nyquist programming language. This code sample can directly be imported in Audacity as a Nyquist plugin.

Points to note:

• This plugin produces a single-side-band modulated signal with a suppressed carrier.
• The sample rate must be more than double the frequency of the modulation carrier frequency. So, for example, if you wish to use a carrier frequency of 17500 Hz, then the sample rate of the secret audio must be more than 35000 Hz. You can use the “Tracks menu > Resample” option in Audacity, if this condition is not satisfied for your secret audio.
• Most of the speakers and headphones reliably transmit audio up to 20,000 Hz. This is one reason why in my example, I will use a near-ultrasound carrier frequency range (17.5 kHz).
• Make sure that when you export the processed audio, the sampling rate in “Project rate” is more than double the carrier frequency.

For this demonstration, let’s assume that we want to transfer the same song by the artist Nucleya, that we used in the earlier example. This will be our “secret” audio.

Frequency distribution for our secret audio shows that the data is well spread in the spectrum.

We will hide this audio within the below music by The Indian Jam Project. This music is their rendition of the Interstellar theme music. This will be the “public” cover for our secret audio.

This is what frequency distribution for public audio looks like.

Next, we use the above Nyquist code to convert our secret to a subliminal audio. Here I am using the carrier frequency of 17500 Hz. You can use a different level as per your requirement and capability of the sound card. The output audio confirms that the secret is inaudible (it may still be audible to young people who have healthy hearing range).

Frequency distribution for the subliminal confirms the modulation.

Next, we mix the public audio and modulated secret audio to create a mixed output that has our secret in the audible range. This embedded audio file shall be sent to the intended receiver.

The frequency distribution for the mixture looks great.

At the receiver end simply run below code to extract the original secret.

Below is the extracted secret audio data.

The sound quality is a bit poor, because for a sample rate of 44100 Hz and a carrier frequency of 17500 Hz, the audio bandwidth is less than 4500 Hz, which is not enough for high-quality audio. Hence, you should expect some distorted speech signal, because there is not much “room” for sound quality in the range between 17500 and 22050 Hertz on a soundcard with only 44100 Hertz sample frequency. I encourage you to repeat this experiment with higher range for carrier frequency if you have a better sound card at your disposal.

That’s all from my side for this post on Audio Steganography. I hope you enjoyed learning about this cool concept, and I would love to hear your feedback in the comment section below.

The word “Steganography”, like many other cool terms, has a Greek origin. It is derived from two Greek words steganos, meaning “covered,” and graphein, meaning “to write”, and refers to the art of enabling covert communication that uses clever methods to hide information in plain sight.

The earliest recorded use of this word dates back to 440 BC, when Histiaeus; the Persian Chief Miletus; shaved the head of one of his servants and tattooed a secret message the servant’s scalp. The message got covered, when the servant grew his hair back. And Histiaeus sent the man to Aristagoras who shaved the man’s head and read the secret message.

And also when Demaratus fooled the Persian spies by covering the engraved wooden tablets with wax to secretly forewarn Greece of the arrival of Xerxes’s naval fleet.

Perhaps one of the more notoriously known examples is of the time of when North Korea captured the crew of USS Pueblo and forced the ship’s crew to pose in propaganda photos to make it look like to they were being treated fairly. The crew actually decided to make hand-gesture in the clicked pictures to covertly protest their captivity.

As you would notice, in all of these incidents the “secret” message was covertly placed inside another message or document such that it remained imperceptible to the unintended receiver.

Steganography Vs Cryptography

Note that Steganography is not the same as Encryption / Cryptography. In Steganography we do not aesthetically alter the publicly communicated message, meaning that the intelligibility of the “carrier” message remains intact. This has an important advantage that “public” message doesn’t attract undue attention to itself, and the fact that this message is carrying a “secret” message is not known to eavesdroppers. On the other hand, encrypted messages are masked using well-known algorithms and arouse the curiosity of hackers and/or researchers to try and break the encryption.

(Remember the time in primary school, when you returned your crush’s notebook with a confession written at the back in invisible ink? That was Steganography. Now you know!)

Audio Steganography

While in theory, you can conceal any text, file, image, audio or video within another text, file, image, audio or video; I will only deal with audio domain examples in this article. Audio Steganography is the art of covertly embedding secret messages into digital audio.

What’s the trick behind Audio Steganography?

The key to all of the methods that we will discuss is that we are going to exploit the Human Auditory System. Due to its anatomy, the human ear can pick up the vibrations of a membrane between the frequency range of 20 Hz and 20 kHz. The actual range for a person may vary based on various factors such as age, gender, and health. For example, the upper limit for a middle-aged adult is usually about 12–15 kHz, and it further degrades with age. Also, the hearing range for men degrades quicker than that of women.

Hearing range for animals is different from humans. For example, with its big ears, an elephant can hear “infrasounds” (sounds lower than the human range of 20 Hz) such as a heartbeat of 1 or 2 Hz. And similarly, dogs can hear “ultrasounds” (sounds higher than the human limit of 20000 Hz) such as a dog whistle.

So one way to achieve the Audio Steganography would be to use Infrasound and/or Ultrasound range to transmit our “secret” message, which would be accompanied by a “public” audio data being played on the audible frequency range, in order to deceive the unintended receiver. In the coming sections, I will explain this method in more detail.

Case in point

There have been many instances in history when the applications that use Audio Steganography methods have attracted some major news headlines. I will share some examples here to help you understand some of the possible applications that Audio Steganography can have.

1. Malicious apps on mobile phones can lookout for the inaudible sounds

In 2014, SilverPush, a Gurugram-based Indian advertisement company, was found to be using unscrupulous means to track users across multiple devices. All of the apps that used SilverPush’s SDK, were able to listen to the “audio beacons” through the phone’s mic in order to facilitate a more effective user habit tracking. These beacons were covertly transmitted as ultrasonic sound waves coming from the company’s advertisement running on television or in a web browser running on a computer. These secret triggers were, of course, imperceptible to the device owners.

2. Hidden sounds can trigger the smart home devices

Earlier this year, Amazon announced that it had taken steps to ensure that the Amazon Echo devices in viewers’ home will not get unintentionally activated during the Super Bowl ad for Alexa devices. It is speculated that Amazon made clever use of acoustic frequency range to achieve this.

The point to note here is that the same concept can be extended to inaudible audio waves from seemingly innocuous sources such as television, that may interface with smart home devices unbeknownst to the device owners.

3. A ringtone that only the young people can hear

You might have heard of The Mosquito. It is an electronic device that is used in some countries to deter young people from congregating, mainly outside shops and marts, and hopes to reduce anti-social behavior such as loitering and vandalism. It works on the simple principle that hearing range for humans deteriorates with age. So the ultrasounds that The Mosquito produces, can only be heard by the young people. To cause slight discomfort, these audio waves could also be transmitted at higher sound pressure levels.

Taking advantage of the fact that the cellphones are generally capable of producing and recording ultrasounds, some teenagers recorded the sounds from The Mosquito to their smartphones and began to use it as call ringtone in order to get away with using phones in classrooms. This ringtone is also commercially available now.

The point to take away from this is that if your target audience or the intended receiver of the message is young, you can use near-ultrasound ranges to encode your “secret“ message.

Below is an audio sample to replicate “The Mosquito Ringtone” effect. You can use it to see if you can hear the infamous “Teen Buzz” sound

17.4 kHz for below-23 age group:

21 kHz for below-20 age group:

4. Hidden sounds in movies to play with your emotions

Have you ever wondered why the horror movies feel scarier at your local movie theatre (that is equipped with Dolby Sound), compared to watching the same movie at home? Well, with Audio Steganography the filmmakers can use infrasounds to unnerve the audiences.

Studies have shown that the infrasounds (extreme bass waves) can cause the feeling such as sorrow, unease, fear, panic, depression and physical sensations. A famous paper titled “The Ghost in the Machine” published in the 1990s talked about how a broken metal fan in the lab of Vic Tandy, a British Researcher, caused him to experience a supernatural presence. The sound produced by the fan was measured to be at 18.98 Hz, which is below the human hearing range and is very close to the resonant frequency of the eye (18 Hz) defined by NASA.

If you are interested in knowing more about the acoustic trickery used in cinemas, I recommend watching the below Ted Talk.

5. Silent Subliminal Technology

Some people believe in subliminal audios to be influential to the subconscious mind. It is known that certain frequencies activate particular areas of the human brain. The proponents of subliminal methods advocate listening to useful audios such as self-help recordings as ultrasounds. The basic idea is that even though the audio playback will be completely “silent” to the human ear, but the human subconscious mind can still listen to these audio and take advantage of the positive influence of the audio content. Usually, these subliminals are mixed some other audible acoustics so that the listener doesn’t feel bored with the “silence” of subliminals. Also, at present, there is no clear evidence that proves the effectiveness of the subliminal technology.

So, How about a quick hearing range test?

“Experiments have shown that a healthy young person hears all sound frequencies from approximately 20 to 20,000 hertz.”

- Cutnell, John D. and Kenneth W. Johnson. Physics. 4th ed. New York: Wiley, 1998: 466.

As explained earlier, a person’s hearing range deteriorates based on various factors such as age, gender, and health. You can use the following audio files to test your current hearing range.

NOTE: I have made sure to keep the “loudness” of these audio files to be much lower than the limit that might be remotely damaging to the human ear, and each frequency is within the human audible range. But I still recommend not using earphones to listen to these audios for a long duration.

Lower Bound Test:

Upper Bound Test:

(Maybe leave a comment below with your age, gender and hearing range?)

By now you should have a good understanding of the Audio Steganography concept. In the next installment of this two-part writing, I will describe some of the methods to achieve the magic of Audio Steganography along with the hands-on examples with accompanying code/tools.

Thank you for reading this article. Feel free to leave your comments/questions /feedback in the comments section below. And I will see you in the next one!

Edit: Part 2 is live! Access it using the link given below.

Audio Steganography : The art of hiding secrets within earshot (part 2 of 2)

The commercially captured satellite imagery that is available in SpaceNet dataset provides wide array of opportunities for advancements in computer vision and machine learning. This article attempts to create understanding and awareness for SpaceNet dataset for those who are unfamiliar with it.

What is SpaceNet ?

SpaceNet is a publicly available dataset containing commercial satellite imagery. This imagery is accompanied by labelled information that can be used to train machine learning models. CosmiQ Works, Radiant Solutions and NVIDIA have partnered to release the SpaceNet data set to the public in order to foster innovation in the field of computer vision with algorithms that can automatically extract geometric features such as roads, buildings etc.

Dataset Source

In order to better understand the dataset, it is helpful to know from where the data is sourced. The satellite imagery is provided by Digital Globe, an American vendor of space imagery and geospatial content. Digital Globe owns a “constellation” of satellites that capture high quality remote sensing imagery. The satellites include QuickBird, GeoEye-1 and the WorldView Series (WorldView-1, WorldView-2, WorldView-3 and WorldView-4). The data generated from each satellite varies in terms of features such as resolution, geolocational accuracy etc.

What locations are covered in SpaceNet?

SpaceNet contains satellite data for 5 Area of Interests (AOIs). Below table summarizes the data in 5 AOIs.

In the round 1 of SpaceNet Challenge(Nov, 2016) open corpus of imagery from WorldView-2 satellite for Rio De Janeiro (AOI_1 location) was used. This imagery was 50 cm mosaic of Ground Sample Distance (GSD) with eight spectral bands. In round 1, 42 developers competed in an open challenge hosted by TopCoder to create algorithms that extract building footprints from satellite imagery.

The next phases of the SpaceNet Challenge are a follow-on competition using DigitalGlobe’s 30 cm imagery from WorldView-3 and building footprints across four new geographically diverse cities spread around the globe. These datasets now have multiple imagery formats (panchromatic, multi-spectral, RGB-pansharpen, multispectral-pansharpen) to allow experimentation with different types of imagery. Also, the data is available for download in training-test split.

How much area is covered?

Below visualization show the geographical area covered in the SpaceNet dataset for all AOIs.

Understanding the Dataset

For better understanding, you can visualize the SpaceNet dataset to be divided in 2 categories: vector data and raster data.

In vector representation, we describe the data in terms of geometric shapes such as points, lines and polygons. This representation is usually written in a mark-up language syntax (such as Well-Known Text) and explicitly stores the actual coordinates of vertex.

In Raster representation(including imagery), we divide the area in equal squares and assign characteristics to these squares. For example, we may use a 2-dimensional matrix to represent an area. Other than an origin point, e.g. bottom left corner or top-left corner, no geographic coordinates are stored.

Now, let’s take a look at both kind of data in the context of SpaceNet.

Raster data in SpaceNet

Raster data in SpaceNet dataset is present in the form of .tif images. These GeoTiff images are a special format of image data which incorporate meta-data that can be used for georeferencing an image and how a pixel in the image is mapped to real world distances.

The Rio de Janeiro dataset (AOI_1) used in Round-1 of SpaceNet challenge, is formated slightly differently and is missing pansharpened, 8-band and multispectral data. This dataset only contains RGB channels pansharpened to a resolution of 0.5m. In all the other datasets, you would observe following directory structure for both train and test data.

Most commercial satellites capture imagery over multiple coarse resolution multispecral bands as well as a finer spatial resolution panchromatic band. This is done because of the tradeoff between the spectral resolution (i.e. the range of wavelengths that are sampled by an imaging detector) and the spatial resolution (read more). Spacenet dataset provides us images with panchromatic, RGB and 8-band channels. Let’s discuss the characteristic properties of these images.

MUL/RGB

The 8-band, multispectral images include the following bands: Coastal Blue, Blue, Green, Yellow, Red, Red Edge, Near Infrared 1 (NIR1), and Near Infrared 2 (NIR2). These images have a resolution of ~1.3 m. However, 8-band and RGB images can have their resolutions increased to their respective satellite’s panchromatic resolution through pansharpening. This pansharpening to ~0.3m resolution is already done for MUL and RGB images in their respective -PanSharpen directories.

PAN

Panchromatic images are single band images for which the sensor is sensitive to all wavelengths of visible light, hence providing most realistic reproduction of a scene.This imagery is extremely useful, as it is generally of a much higher (spatial) resolution than the multispectral imagery from the same satellite. Panchromatic images are generally displayed as shades of gray and are also used to perform pansharpening for multispectral bands.

But what is the advantage of having different types of images?

Images captured by WorldView-3 satellite vary in terms of wavelengths as shown below:

As you can see in the above image, the RGB bands in 8-band images do not include Yellow band. Separating Yellow and also including Coastal Blue bands allow for novel feature extraction such as vegetative analysis by providing “yellower” and “bluer” information of objects. The Red-Edge (705–745nm) provides wavelengths of light just beyond the Red wavelengths. The significance of this channel is that Chlorophyll is transparent to wavelengths > 700nm, leading to nicer application for vegetative analysis. Near Infrared (NIR) bands 1 & 2 can be used to perform NIR spectroscopy, whose applications include investigating plant health, soil conditions and atmospheric analysis.

Vector data in SpaceNet

Vector data, such as building footprints, are provided in SpaceNet dataset in both CSV and GeoJSON formats. The CSV provides the coordinates of the vertices of the building footprint (polygons) as latitude and longitude in the same map projection as the images, and the GeoJSON provides this same information in pixel coordinates relative to the image.

CSV files are present in “summaryData” directory and GeoJSON files are present in “geojson/buildings” for buildings’ labels or inside “geojson/spacenetroads” for roads’ labels. Note that the vector data is, understandably so, available only for training datasets.

If you are new to GeoJSON standard or want a refresher on it, I recommend reading this article that I wrote for explaining GeoJSON standard and tools that you might use to visualize GeOJSON data.

A primer on GeoJSON standard and visualization tools

Download the Datasets

SpaceNet dataset is available on AWS in “Requester Pays” S3 buckets, meaning that the requester instead of the bucket owner pays the cost of the request and the data download from the bucket. You can use aws-cli to download the datasets by following these instructions.

Visualize the Data

Visualizing data is a good way to familiarize yourself with the nature of quality of your dataset. As an example, I am going to visualize the sample data available in the SpaceNet dataset. Also, I will use QGIS software to visualize vector and raster data of SpaceNet. QGIS is a free, open-source cross-platform software for viewing, editing, and analyzing geospatial data.

QGIS Browser

Similar to what ArcCatalog is for ArcGIS, QGIS Browser is the standalone visualization application in QGIS that comes bundled with default QGIS installation. You can use QGIS Browser to have a quick look at your geospatial data.

• Open “QGIS Browser” on your computer and use the left pane to browse to the directory that contains SpaceNet data. The “Preview” tab in right pane will show you a quick preview of the data points, after you click on .geojson, .tif or .csv file.

• Switch to the “Attributes” tab to see the associated attributes values for the vector data.

QGIS Desktop

QGIS Desktop is the “batteries included” standalone application in QGIS package. We will use it to map over vector data over raster imagery.

• First open the .tif file in QGIS Desktop, using menu option Layer -> Add Layer -> Add Raster Layer.

• You should now to able to see the raster preview and the raster image should be added in the “Layers” pane, as shown below.

• Now open the vector (geojson) file using Layer -> Add Layer -> Add Vector Layer->Browse menu options.

• You should be able to see vector data layer overlaid on raster layer. If not, make sure your vector layer is above the raster layer in the “Layers” pane. You can change this by simply dragging and dropping a layer above or below another. You can also customize the line width and color for the drawn vector by double-clicking on the corresponding layer and choosing the respective option.

Note: The SpaceNet data has both vectors and rasters numbered according to the index of grid they represent. To see overlay, use same indexed vector and raster data. For example, we used RGB-PanSharpen_AOI_2_Vegas_img517.tif as raster and spacenetroads_AOI_2_Vegas_img517.geojson as vector data.

You can also open multiple raster and vector files to visualize more grids together.

Hopefully this article was helpful for you to start working with SpaceNet data. In the next article, I will explain how to use Python to work with SpaceNet data. Thank you for your time and I will see you in the next one! :)

Well, the name GeoJSON (Geo+JSON) itself is a giveaway. The GeoJSON is a format for encoding geographical data structures, using the JavaScript Object Notation (JSON). Simply put, GeoJSON gives you an easy format for representing simple geographical features, along with their non-spatial attributes.

As described in the RFC, JSON was designed to be a lightweight, text-based and language-independent data interchange format that is easy for both humans and machines to read and write. And GeoJSON basically uses this design strategy to represent data about geographic features, their properties, and their spatial extents.

Fancy an example ?

Does the structure make sense ? No ? Read on!

So, what all goes inside a GeoJSON object ?

Glad you asked! A GeoJSON object can define the followings:

• Geometric objects in space: for example, a Point, LineString or Polygon etc.
• Features: A feature is a spatially bounded entity.
• List of Features: Also known as a FeatureCollection.

Okay, this terminology might be too much to digest at once. So, let’s look into each part one-by-one.

Geometric Objects

Geometry objects represent points, curves, and surfaces in coordinate space. The GeoJSON RFC defines 7 “types” of a geometric shapes that a GeoJSON object can represent. These are “Point”, “MultiPoint”, “LineString”, “MultiLineString”, “Polygon”, “MultiPolygon”, and “GeometryCollection”.

Point, LineString and Polygon shapes are also known as single type Geometry objects. While MultiPoint, MultiLineString, and MultiPolygon are also called homogeneously typed multipart Geometry objects.

Construct for many of these shapes will become clear once you understand the concept of a Position.

A Position is a fundamental geometric construct. Simply put, it is an array of 2 or three numbers. The first two numbers represent longitude and latitude(in that order). And the third (optional) number represents altitude or elevation. So, a position is basically the array [longitude, latitude, elevation/altitude].

NOTE: Among different geographical tools or libraries, there seems to be no common consent about whether the ordering should be [longitude, latitude] or [latitude, longitude]. For example, Google Maps API and Leaflet.js expect the coordinates to be [latitude, longitude] while GeoJSON, shapefile, D3.js, ArcGIS API expect the coordinates to be in the format [longitude, latitude]. So, always be wary of what order is required for your application. For reference, you could use the below table compiled by Tom MacWright on his blog.

All geometric shapes have two key value pairs defining that shape. You might have also noticed them in the sample GeoJSON object you saw above. The two keys are type and coordinates. “type” must be one of the seven types we saw above and “coordinates” is an array of Position values. The exact structure of the elements in this array is determined by the type of geometry.

Point: As you can guess, if we want to represent a Point geometry, we need to have one position. So, we can define a Point in GeoJSON as:

{ "type": "Point", 
    "coordinates": [30, 10]
}

MultiPoint: The “coordinates” value would be an array of Position objects for a MultiPoint object.

{ "type": "MultiPoint", 
    "coordinates": [
        [10, 40], [40, 30], [20, 20], [30, 10]
    ]
}

LineString: For LineString, we need to provide two positions, i.e. the start and end points of the line segment. For example:

{ "type": "LineString", 
    "coordinates": [
        [30, 10], [10, 30], [40, 40]
    ]
}

MultiLineString: For type “MultiLineString”, the “coordinates” member is an array of LineString coordinate arrays.

{ "type": "MultiLineString", 
    "coordinates": [
        [[10, 10], [20, 20], [10, 40]], 
        [[40, 40], [30, 30], [40, 20], [30, 10]]
    ]
}

Polygon

Polygons in GeoJSON standard, are slightly more complex than the other geometric shapes. A Polygon is defined in RFC document as “For type “Polygon”, the “coordinates” member MUST be an array of linear ring coordinate arrays”. So to understand a Polygon definition, we must first have a look at the LinearRing concept.

A LinearRing is a closed LineString with four or more positions. “Closed” simply means that the start and end point of the LinearRing must be the same Position. A Polygon in GeoJSON format is specified in terms of multiple LinearRing shapes. The outer boundary of the Polygon is one LinearRing, and there could be multiple other LinearRing shapes defining the other intricate ring shapes inside that Polygon.

As per the standard, the first LinearRing array inside the “coordinate” array must be the exterior ring and all following LinearRing arrays define the interior rings. RFC 7946 also defined winding order for these rings, which specifies that the exterior rings Position are defined counterclockwise, and interior rings Position values are defined clockwise. This winding order is useful for many drawing APIs.

{ "type": "Polygon", 
    "coordinates": [
        [[35, 10], [45, 45], [15, 40], [10, 20], [35, 10]], 
        [[20, 30], [35, 35], [30, 20], [20, 30]]
    ]
}

MultiPolygon

For type “MultiPolygon”, the “coordinates” member is an array of Polygon coordinate arrays.

{ "type": "MultiPolygon", 
    "coordinates": [
        [
            [[30, 20], [45, 40], [10, 40], [30, 20]]
        ], 
        [
            [[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]]
        ]
    ]
}

GeometryCollection

A GeometryCollection is a heterogeneous composition of the other geometry types you saw above. A GeometryCollection object has no “coordinates” member, instead it has a member named “geometries”. The value of “geometries” is an array. Each element of this array is a GeoJSON Geometry object. It is possible for this array to be empty.

{ "type": "GeometryCollection", 
    "geometries": [
      {
        "type": "Point",
        "coordinates": [0, 0]
      }, {
        "type": "Polygon",
        "coordinates": [[[45, 45], [45, -45], [-45, -45], [-45, 45], [45,45]]]
       }
    ]
}

Feature Object

The Geometric shapes that you saw in last section, define shapes that can be plotted on a map. However, our shapes on map should also have some real-world meaning. This meaning is defined by attributes of that shape. For example, a building marked by a Polygon on map could have a name property like “Taj Mahal” and possibly some other parameters further describing the shape. In GeoJSON, an object of type “Feature” defines both the gemoetric shape and attributes for an entity.

The Feature object has a member with name “type” with the value “Feature”. It also has a member with the name “geometry” with value of any geometric shape that we discussed above or a null value. Further, it has a member with the name “properties” whose value is a JSON object (or null value) defining the attributes for that object. It can also have an optional “id” member with a unique string or null value specifying an identifier for the Feature.

As an example of Feature object, take a look at the sample GeoJSON object that you saw at the start of this article.

I hope it makes more sense now.

FeatureCollection Object

A FeatureCollection object is a composition of Feature objects. It is the most common top-level construct you will observe in a GeoJSON file. It has a member “type” with value “FeatureCollection” and another member with name “features” with array of Feature object as value.

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [-80.83775386582222, 35.24980190252168]
      },
      "properties": {
        "name": "DOUBLE OAKS CENTER",
        "address": "1326 WOODWARD AV"
      }
    },
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [-80.83827000459532, 35.25674709224663]
      },
      "properties": {
        "name": "DOUBLE OAKS NEIGHBORHOOD PARK",
        "address": "2605  DOUBLE OAKS RD"
      }
    }
  ]
}

Miscellaneous: Bounding Box

A GeoJSON object might also contain a bounding box that defines the bounding range for the GeoJSON object. For example, in a 2-dimensional geometry, a bounding box is simply a member with name “bbox” and an array of four numbers as values. These four values define the rectangle that contains the complete GeoJSON object.

{
       "type": "FeatureCollection",
       "bbox": [100.0, 0.0, 105.0, 1.0],
       "features": [
       //...
       ]
}

Cool! So now that you know the basics you need to master GeoJSON data, let’s take a look some of the tools that you can use to visualize the GeoJSON data.

How to visualize GeoJSON data ?

In this section, I will share some of the popular GUI based tools that you may use to quickly visualize the GeoJSON data. Tom MacWright has an exhaustive list of utilities that convert, process, and analyze GeoJSON data on his Github.

GitHub - tmcw/awesome-geojson: GeoJSON utilities that will make your life easier.

For a Python based environment such as a Jupyter Notebook, you might use a module like GeoPandas. Twilio has a nice little tutorial using Shaply and GeoPandas.

Getting Started on Geospatial Analysis with Python, GeoJSON and GeoPandas

Google Developers — GeoJSON appspot

On this web app, you can plot geometric shapes directly on Google Maps and visualize the GeoJSON code side-by-side in two panes. This visualization is really helpful to understand GeoJSON concept. You may also download .geojson file in a single click.

geojson.io

geojson.io is a web-based editor where you can import and export GeoJSON data. It also shows you GeoJSON code and visual output in side-by-side panes.

QGIS

QGIS is a free, open-source cross-platform software for viewing, editing, and analyzing geospatial data. GeoJSON format is supported by QGIS, along with plethora of other geospatial data standards. You can download and install latest QGIS software from here. As an example, I will use the crime incidents data of Nanaimo city of Canada. This data is available here in GeoJSON format.

• Open “QGIS Browser” on your computer and browse the .geojson file in the left pane. The right pane will show you a quick preview of the data points.

• You may also view attributes by clicking on the Attributes tab next to Preview tab.

In the next article, I will explain how to overlay the GeoJSON data on a raster data layer using QGIS Desktop. I will be using Spacenet satellite imagery dataset available on AWS.

I hope this article was helped you to better understand the GeoJSON standard. Thank you for your time! And I’ll see you in the next one! :)

Edit: The follow up article with SpaceNet dataset is live. In this article, you will learn about the high resolution satellite imagery made available in SpaceNet and how to access and visualize it.

Getting Started with SpaceNet data

As a student at the University of Chicago, I regularly use the university’s Canvas portal to access class materials. However, this portal, along with a few uChicago portals require the user to take some unnecessary navigational steps to download files. So, I decided to make a Chrome extension that allows the user to download all the course material in a single click, right from the course page, without having to go to each module and then click each file link separately.

To do this, I designed my extension in such a way that it will scrape the current page and all the linked webpages to fetch a list of available downloads links. And then display the module-wise download buttons to the end-user, to enable bulk downloading of all the files with a single click. In this post, I will share the learning from making my first Chrome extension.

Building blocks of a Chrome browser extension

To create a Chrome extension, you need to have following components:

1. manifest.json file
2. Popup page
3. Content script
4. Events page

Let’s discuss each of the component one-by-one.

Create Manifest.json

This file is basically some metadata in json format that contains basic properties about our extension, such as extension’s name, description, version number etc. For more information about manifest file, read Google’s Manifest File Format documentation.

At a bare minimum, our extension needs below content:

{
 “manifest_version”: 2,
 “name”: “UC Grabber”,
 “version”: “0.1”
}

manifest_version has to be 2. Since manifest version 1 has been deprecated in Chrome 18. (read more here)

Let’s add a bit more jazz in our manifest by supplying a plain description, an icon and a popup window that will open when user click on the extension icon.

{
  "manifest_version": 2,
  "name": "UC Grabber",
  "version": "0.1",
  
  "browser_action": {
    "default_icon": "images/icon.png",
    "default_popup": "html/popup.html",
    "default_title": "Grabber for uChicago Canvas!"
  }
}

• As a good practice, we will keep images, scripts and html files in their respective directories and refer to them with a relative URL.
• icon.png will be a 19-px square PNG file. Use any file that you want to be used as the icon for your extension.
• popup.html: Simple html file whose content will be populated inside the small window that pops-up when a user clicks on the extension icon.

Let’s create a sample ‘popup.html’ file with just ‘Hello world!’ inside it and test our extension. To test the extension in chrome, click the hamburger menu, go to More tools -> Extensions. Enable “Developer mode” on the top-right and click “Load Unpacked Extension” button, now browse to the main directory where manifest.json is located, click ok.

and Voila! our cute little extension is up and running.

Create Content script

As our script needs to access content inside the webpage loaded by user, it needs a content script. This script will be equivalent to a JavaScript file that is loaded by the browser as part of the webpage. You could read more about content scripts here.

For our purpose, our content script will check the webpage to see if the URL of the current page belongs to our target website, which happens to be Canvas portal URL in this case. If it is Canvas URL, content script will fetch downloadable links from the webpage and pass it onto the popup.html page so that user can be shown the options to download the desired files.

Note: Content script can’t directly modify the content of it’s parent extension, but we can always pass the desired download content to the parent extension.

We will connect the content script with the manifest file. By passing in the “matches” key, we ensure that we call our content.js script only when the URL matches

{
 “manifest_version”: 2,
 “name”: “UC Grabber”,
 “version”: “0.1”,
 
 “permissions”: [
 “activeTab”
 ],
 
 “browser_action”: {
 “default_icon”: “images/icon.png”,
 “default_popup”: “html/popup.html”,
 “default_title”: “Grabber for uChicago Canvas!”
 },
 
 “content_scripts”: [
 {
    "matches": [
  "*://canvas.uchicago.edu/*"
    ],
    "js": ["scripts/content_canvas.js"]
  }
]
}

In our project, content script will scrape the webpage and fetches the desired URLs. The exact scraping expression will depend upon the webpage that you want to scrape, and how the desired url is nested among html tags.

Of course, you can you any of your favorite JavaScript library to make your content scripts more efficient. As an added feature, I made my extension to be able to insert download buttons in the webpage itself. So, I used jQuery to manipulate DOM based on my needs.

Create Event Page

Event pages are the single long-running scripts used to manage certain tasks and states. Chrome supports and recommends using event pages since Chrome 22. Event pages carry advantage over background pages that they are unloaded when they are not active, hence consuming lesser memory. This performance optimization becomes significant, especially on low-power devices.

Event pages will get loaded in below situations:

1. Extension is first installed or is updated to a new version.
2. An event is dispatched.
3. Content script sends a message.
4. Popup view calls background page.

Why do we need events script ?

In our extension, the content script scrapes the webpages and creates a JavaScript object of the download file titles and download links. This JavaScript object is sent to the popup which is supposed to show the download buttons to the end-user. But there is one problem! The popup page can only listen to the content script only if the popup window is open. And as you can imagine, the end-user might not want to keep waiting for the result with popup window open all the time (Note: popup window gets closed when user switches to another tab). So, we need an intermediary script between content and popup, and the events script does just that.

In our extension, the events page will temporarily save the download information scraped by content script in a local JavaScript object that neatly stores download information returned by each tab organized by respective tab id. So that when popup view is opened, it asks for scraping status of the content script to the events script. If the scraping is done, the events script simply checks the tab id for the tab for which popup window is requesting scraping status and simply returns the stored information to popup. Similarly, if scraping is ongoing, the events script has to maintain status for the respective tab so that end-user can be shown some wait-screen animation, such as one in the next section.

Create Popup Page

The popup window is the “front-end” of your extension. This is the interface that the user sees and interacts with. Simply put, a popup window is just an HTML file that is displayed each time end-user clicks on the icon of your extension. In our project, this popup window gets the start scraping request from user, shows the available download options to the user, and communicates with the events page to fetch scraping status and results. Also, to make your extension appealing, you can also add certain animations in terms of loading, waiting, results etc. For example, in my extension, user sees below gif file as waiting screen, when the scraping is ongoing at the content script.

Note that this animation is actually a gif file, that can be stored as part of your extension, or you could also render an image hosted elsewhere on the internet.

And by utilizing the “matches” parameter of the manifest file. We can also show some attractive screen to the user for the websites that are not supported by the extension.

With that we have the knowledge of all the necessary concepts required to build a Chrome Browser Extension. When you are done with unit testing, you can publish your extension using the Official Chrome Developer Dashboard. To activate the developer account, you need to pay a one-time activate fee of 5$. This should set you up for publishing up to 20 extensions on Google Chrome Web Store.

The extension that I made is available here on Google Chrome Web Store. The complete source code is available on the project repository on my GitHub. You can also check out the extension in action on this post.

With that, I hope I could inspire you to start working on a project of your own. Thank you for reading this post! And I will see you in the next one! :)

How to make a Chrome browser extension from scratch | Understanding extension architecture was originally published in Frontend Weekly on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hope you’re doing well!

I just want to share a software that I wrote in last few days, to automate some routine and mundane tasks. I think it might be useful for all of us who use Canvas and/or ilykei.com portal.

The Problem

The problem that I wanted to solve was very simple, both of these websites require students to take some unnecessary steps to download files. For example, to download the lecture materials for a certain week’s module, one has to click on each link and open all the files in their respective tabs and then click the download link for each file.

Similarly, for ilykei.com, a user has to go through each link to download course material.

Also, as per the default behavior, single click on .html workshop documents opens them in a new tab. And also, the downloaded files retain the ASCII URL encoding characters.

So, to be able to easily download content from Canvas and/or ilykei.com, I developed an application that can be installed in our browser. Its purpose is to provide easy, one-click workarounds to the above problems that I mentioned. This application can be installed as a chrome extension from the official Google Chrome Web Store.

How to use this extension?

Say for example, if I want to download the course material for Data Mining class, I would go the data mining module page on Canvas, and then click on the extension icon next to the address bar, then click the Process button.

Parsing might take a few seconds, depending upon the number of modules/files on the page.

In a few seconds, you should be able to see a list of buttons, clicking on a button would download all the available files for the corresponding module. The downloads are organized in directories named according to the module.

Here are the complete steps:

On ilykei.com, if you navigate to a lecture page and click on the Process button, the extension will put two download links on the lecture page itself.

Clicking on the first link would download all the documents in the lecture material. And clicking on the second link would download all the documents in the sidebar. See this in action below:

Link?/How to install this extension?

1. Make sure you are using Google Chrome

2. Go to this URL: https://chrome.google.com/webstore/detail/uc-grabber/dimmeocemhglaadjicpnogdadmkkgpln

3. Click “Add To Chrome”

4. You’re set! :)

Tl;dr?

Download this extension https://chrome.google.com/webstore/detail/uc-grabber/dimmeocemhglaadjicpnogdadmkkgpln. It makes it easy to batch download documents from Canvas/ilykei.com

The complete code for this project is available on my GitHub. I tried my best to handle all the possible corner cases, but if you still find a bug, please let me know. And I would appreciate if you also let your uChicago friends know about this extension.

Thank you. And I hope this extension is helpful for you! :)

TensorFlow is an open-source library for numeric computation using dataflow graphs. It was developed by Google brain team as a proprietary machine learning system based on deep learning neural networks. TensorFlow is causing quite a stir in research and development field and is set very to make its way into mainstream machine learning.

In this tutorial, we are going to make an Android app that uses a neural network trained by TensorFlow. For our purpose, we will use a special class of convolutional neural networks called MobileNets. As also suggested by the name, the special thing about the MobileNets is that they are “mobile-friendly”, meaning that they are optimized to be executed using minimal possible computing power on a smartphone device.

As you can imagine, there has to be a catch with something so customized for a minimal resource footprint. MobileNets do not provide as good of an accurate model as produced by a full-fledged deep neural network. However, the accuracy is surprisingly very high and good enough for many applications. Below graph shows the graph of accuracy versus the number of calculations required for a choice of neural network libraries. Model size is shown as the size of circle, and different model size of the MobileNets show the tradeoffs assumed during selection of model parameters. See this Google research blog post for more details. We will also come back to the choice of model parameters later.

Data collection

The image classifier that we are going to train in this example will be able to classify cars to their respective model. We are going to use “Cars Dataset“ made available by Stanford. [Link to dataset ~ 1.8GB]

This dataset consists of 16,185 images of 196 classes of cars. The label information for this dataset provides make, model and year for each of the 196 classes. The data is also available as separate train and test sets in a 50–50 split. But for this project, we will download the full dataset of 16,185 images, along with the label information.

Data Preprocessing

The image dataset from the Stanford is organized as a single directory containing 16,185 images of cars. To use these images for our training step, we need to reorganize these images so that each car image is inside a directory that contains all the images for a single class. Also, the name of the directory should reflect the name of the corresponding class. We will use the label information available in the .mat file provided by Stanford. Below Python script performs this task.

Edit: As correctly pointed out by a reader, I missed specifying that the name for class 174, i.e. ‘Ram C/V Cargo Van Minivan 2012’ has a forward slash, ‘/’, in it and it should be renamed to remove the slash character.

Training the classifier

For training our image classifier, we are going to use the transfer learning concept. Transfer learning basically refers to a supervised learning technique that takes advantage of an already existing trained model that solves a similar problem. For our purpose, we will take TensorFlow’s fully trained model for Imagenet and retrain just the last layer of the neural network on our Cars dataset. Though this approach is not as powerful as a fully trained model, but it can provide a surprisingly high accuracy for most tasks that are related. You can read more about this concept from this article:

How to Retrain an Image Classifier for New Categories | TensorFlow

As mentioned in the above article, you can clone the retrain scripts from this GitHub repository.

As we are only training the final layer of the neural network, the training will end in reasonable amount of time. TensorFlow’s retraining procedure allows you to optimize the training procedure by tweaking certain parameters. Following two are probably the most important of those parameters:

1. Input image resolution: The corresponding value can be 128,160,192, or 224px. As you can imagine training with a higher resolution image will take longer time, but also has higher chances of providing a better classification accuracy. Since, we are only training final layer and our dataset is not very huge, we will keep this value as 224.
2. Relative model size: This value represents the relative size of the model as a fraction of the largest MobileNet. It can take value such as 1.0, 0.75, 0.50, or 0.25. The larger the size of the model, more accurate it will be. For our purpose, we will keep this value to 0.75.

Both the above parameters can be configured as environment variables as:

IMAGE_SIZE=224
ARCHITECTURE="mobilenet_0.75_${IMAGE_SIZE}"

With these parameters setup, let’s run the retrain python script provided by TensorFlow with following parameters.

python -m scripts.retrain 
 — bottleneck_dir=tf_files/bottlenecks 
 — how_many_training_steps=5000 
 — model_dir=tf_files/models/”${ARCHITECTURE}” 
 — summaries_dir=tf_files/training_summaries/”${ARCHITECTURE}” 
 — output_graph=tf_files/retrained_graph.pb 
 — output_labels=tf_files/retrained_labels.txt 
 — architecture=”${ARCHITECTURE}” 
 — image_dir=tf_files/dataset

Above command sets up directory paths for bottleneck, model and summary files. image_dir refers to the directory where our image image data is stored. output_graph and output_labels provides the path where we will store our training model and label information respectively.

Parameter how_many_training_steps is the count of how many times retraining iterates over the data. By default it is set to reiterate 500 times. If you have time, you could increase this iteration count to achieve better results.

There are still a lot more configuration options that the retraining script provides. Run the below command help command to read more about the available options.

python -m scripts.retrain -h

If the final size of your trained model is large, you could look into some of the techniques that can reduces the model size, such as making the model compressible and to quantize the network weights. Refer to below article to read more on this.

How to Quantize Neural Networks with TensorFlow | TensorFlow

Deploying the solution in Android app

TensorFlow GitHub repository contains an Android project that you can directly load into your Android studio and compile directly to create an image classifier application. Simply copy the trained model(graph.pb) and label information(labels.txt) that we generated in the last step, to the project’s “assets” directory And run the Gradle build. This will generate a .apk file that you can run on your computer in a emulator with camera access, or you can deploy it on an Android phone.

Result

The resulting Android app uses the phone’s camera stream to classify objects into the identified class. The application by default also provides probability value of a car belonging to the corresponding category. You could take a look at the Android application that I published on Google Play store to see this project in action.

Which Car Is That ? - Android Apps on Google Play

As you can see transfer learning with TensorFlow makes it easy to quickly build our own classifiers. I hope you liked this article, and I’ll see you in the next one. :)

Pretty neat, right ? This map conveys the point across and also maintains an appeasing simplicity. This inspired me to create a similar population map for my motherland, India.

But what I imagined to be a straightforward task, turned into something really complicated. While the original creator of the above reddit post was able to get the desired data in nicely arranged format from the US Census Bureau website, similar information wasn’t readily available for India. So, I set out to create my map from scratch, And I would like to share that experience with you. :)

Step 1: Set the Goals

• I decided that I would plot comparison of state-wise population for last 2 years for which census was conducted in India (2001 and 2011).
• My preferred choice of programming language is Python. So I need to work out a solution that is Python based.
• For plotting the output, one way in Python could be to create a choropleth map using Plot.ly. But unfortunately, Plot.ly does not support India for plotting country level choropleth maps. So, I decided to use Tableau for plotting the output on a map.

plotly on Twitter

@DHagan7 Right, not in India. Ssetting up CDN to load topojson. That will let us do state-level globally. You could draw your own lines.

Step 2: Defining Process

To create the target map I need the followings:

1. Find a way to map each district in India as a polygon. The borders of the polygon would be the 2-D points (latitude, longitude). Of course, there would be multiple districts in a single state.
2. Find out the mean center for each district that constitutes a state. “Mean” center simply signifies a point inside district on which the district map would balance perfectly.
3. Assign a weight to each district centroid. This weight value is essentially the population of that district. I might need to (web) scrape this population data from some website.
4. For all of the weighted [longitude, latitude] 2-D point inside a state, find one weighted mean centroid that would represent a state in the final map. “Weighted” mean is required because I need to take into account that different districts would have a different population and a weighted mean centroid would be a true depiction of the population center.
5. Plot each state on a map using Tableau. Each state would display two points, one centroid each for 2 census years (2001 vs 2011).

Step 3: Implement the plan

Let’s go step-by-step through the implementation procedure:

Draw Polygons

After searching a bit, I found an excellent source of district-wise longitude, latitude coordinates for India. Tableau user Indumon was kind enough to share a csv file with enough information to plot Indian districts as polygons. You can download the csv file from this link.

Here’s a snippet of this csv file:

And here’s what the polygons look like on a Tableau map:

Calculate Mean Centroids

As you would imagine, there are multiple rows for one district in the above csv file, forming the borders for the districts (polygons). I used shapely Python library to calculate the mean centroids.

Shapely is a BSD-licensed Python package for manipulation and analysis of planar geometric objects. (shapely GitHub)

As also explained in the shapely documentation, it is not guaranteed that the mean center of a polygon would always lie inside the polygon. Imagine a state shaped as English letter ‘L’ or ‘C’ in this case the mean of the coordinates might not lie inside the polygon. But even though shapely does provide a “cheat” method to get a point inside the polygon, I didn’t require it as my initial runs showed that none of the Indian provinces were highly twisted in shape.

To calculate the mean center, I imported the csv data inside a Pandas dataframe and calculated center mean for each of the districts. Below is the code that I used for this task. The code is pretty much self-explanatory.

The output from this step is exported to a csv file. Below is a brief snippet of the output saved in csv file.

Here’s how centroids look like on a Tableau map:

Scrape the population data

After hours of trudging through the sluggish Indian Census Library, I came across City Population website, that neatly displays census data for each district in India, for last 3 decennial Censuses of India. However, this information is available on separate webpages, so next step was to write a simple scraper to get this data into a nicely formatted csv file.

Below code shows the scraping steps and saves the scraped data into a csv file.

As you can see from the code above, the nifty Pandas ability to read tables directly from webpages is very handy, especially for such small tasks. Here is a brief look at the contents of the saved csv file:

Merge the data

At this stage, we have geospatial data for each district in one csv file, and population data for them in a separate csv file. Naturally, the next step would be to combine them. Note that one important reason for having two csv files is to deal with the fact that our geospatial misses a few districts(yes, I counted). So, it is a good option to have our location and population data in separate tables and then perform a join operation on the two, to get the clean merged table of data. The Python code below does it by performing a merge operation on the two dataframes that we have established from above examples.

# merge data
merged_df = pd.merge(df,population_df,on=['District','State'],how='left')
#save merged data
merged_df.to_csv('merged.csv',index=False)
# drop null-valued rows (not recommended, see below)
merged_df.dropna(axis=0,how='any').to_csv('merged_withoutNA.csv',index=False)

In the above code, we performed a merge operation with District and State as key columns. Unfortunately, there are some rows with null values in the above code. This is because the website, that we used to scrape population data, has slightly different naming conventions for a few states and cities (for example, our location data has state name “Jammu and Kashmir” while the population data has “Jammu & Kashmir”, and so on for a few districts). One could write a simple fuzzy match to handle this siutation, but considering that only a few rows had the missing data values, I manually filled out the corresponding population data by reading the numbers from the City Population website.

Calculate Weighted Mean Center

In the previous step, we have effectively assigned weights(population data) to each district centroid. Next step is to calculate the center of population density for each state based on the weighted averages.

First, I considered using ArcGis Pro’s MeanCenter_stats functionality for this purpose. ArcGis has a powerful set of tools for analyzing geospatial data, along with a very useful Python driver arcpy. However, upon diving down into the ESRI documentations, I realized that the mean center implementation technique was pretty straightforward. So, I decided to write my own code to calculate the weighted means, based on below formula.

Below is the Python implementation to generate the desired weighted means.

Repeat the above process for 2011 population data, and we have all the weighted centered means along with the year-wise population data.

Step 4: (Profit?) Plot the Results

Phew! Now that we have all the information we need, the only thing left is to plot the results in tableau to see the state-wise population density trends. And here’s how the output looks like on a Tableau dashboard:

Well, the results are not quite what I was expecting. There has been very little population density movement between the last two decennial Censuses of India. I reckon a city-level density plot, instead of a district-level map might exhibit more interesting movement. But it was a fun little project and I got to learn many new things out of it.

I hope you too learned something new from reading this post. And I hope I could inspire you to work on some mini-project (the way the original reddit post inspired me). Thank you for taking time to read this. Till next time. :)

Edit:
I was requested to plot national center of population density for the data I have. Here’s the output on Tableau: