Code

#!/usr/bin/env python

# coding: utf-8

# In[1]:

# Importing libraries which are to be used

import pandas as pd

import numpy as np

# In[2]:

# Reading the file downloaded from https://www.gbif.org/occurrence/

main_df = pd.read_csv('lomdi.csv',sep='\t')

main_df.head()

# In[3]:

# Just taking important columns and leaving else...

main_df = main_df[['species','decimalLatitude','decimalLongitude','day','month','year']]

main_df.head()

# In[4]:

# Checking that are there null elements in the data.

main_df.isnull().sum()

# In[5]:

# Dropping all null element containing rows

main_df = main_df.dropna()

# Reseting index

main_df = main_df.reset_index(drop=True)

main_df.isnull().sum()

# In[6]:

# Converting day, month, year to string...

main_df['day'] = main_df['day'].astype(int).astype(str)

main_df['month'] = main_df['month'].astype(int).astype(str)

main_df['year'] = main_df['year'].astype(int).astype(str)

main_df.head()

# In[7]:

# Reading air temprature data downloaded from https://datasearch.globe.gov/

temp_df = pd.read_csv('air_temp.csv')

# Dropping empty cells

temp_df = temp_df.dropna()

# Setting date into the required format

temp_df['measured_on'] = temp_df['measured_on'].astype(str)

temp_df['measured_on'] = temp_df['measured_on'].apply(lambda x: str(int(x[3:5]))+'-'+str(x[6:]))

# Setting measured on as index.

temp_df = temp_df.set_index('measured_on')

temp_df.head()

# In[8]:

# Reading soil temprature data downloaded from https://datasearch.globe.gov/

soil_temp_df = pd.read_csv('soil_temp.csv')

# Dropping empty cells

soil_temp_df = soil_temp_df.dropna()

# Setting date into the required format

soil_temp_df['measured_on'] = soil_temp_df['measured_on'].astype(str)

soil_temp_df['measured_on'] = soil_temp_df['measured_on'].apply(lambda x: str(int(x[3:5]))+'-'+str(x[6:]))

# Setting measured on as index.

soil_temp_df = soil_temp_df.set_index('measured_on')

soil_temp_df.head()

# In[9]:

# Reading precipitation data downloaded from https://datasearch.globe.gov/

rain_df = pd.read_csv('precipitation.csv')

# Dropping empty cells

rain_df = rain_df.dropna()

# Setting date into the required format

rain_df['measured_on'] = rain_df['measured_on'].astype(str)

rain_df['measured_on'] = rain_df['measured_on'].apply(lambda x: str(int(x[3:5]))+'-'+str(x[6:]))

# Setting measured on as index.

rain_df = rain_df.set_index('measured_on')

rain_df.head()

# In[10]:

# Reading precipitation data downloaded from https://datasearch.globe.gov/

aerosol_df = pd.read_csv('aerosol.csv')

# Dropping empty cells

aerosol_df = aerosol_df.dropna()

# Setting date into the required format

aerosol_df['measured_on'] = aerosol_df['measured_on'].astype(str)

aerosol_df['measured_on'] = aerosol_df['measured_on'].apply(lambda x: str(int(x[3:5]))+'-'+str(x[6:]))

# Removing duplicate entries...

aerosol_df = aerosol_df.drop_duplicates(subset=['measured_on','latitude', 'longitude'])

# Setting measured on as index.

aerosol_df = aerosol_df.set_index('measured_on')

aerosol_df.head()

# In[11]:

from math import cos, asin, sqrt

# Calculating distance between two points with latitude and longitude...

def distance(lat1, lon1, lat2, lon2):

p = 0.017453292519943295

a = 0.5 - cos((lat2-lat1)*p)/2 + cos(lat1*p)*cos(lat2*p) * (1-cos((lon2-lon1)*p)) / 2

return 12742 * asin(sqrt(a))

# Calculating minimum distant point from data

def closest(data, v):

return min(data, key=lambda p: distance(v['decimalLatitude'],v['decimalLongitude'],p['latitude'],p['longitude']))

# In[12]:

# Getting data of all the parameters of each occurence of species...

for i in range (main_df.shape[0]):

time = main_df.iloc[i][4] + '-' + main_df.iloc[i][5]

v = main_df.iloc[i][['decimalLatitude','decimalLongitude']].to_dict()

try:

time_rain = rain_df.loc[time]

rain_arr = time_rain[['latitude','longitude']].to_dict('records')

closest_rain_point = closest(rain_arr, v)

rain = time_rain[time_rain['latitude']==closest_rain_point['latitude']]['precipitation monthlies'][0]

main_df.at[i, 'rain'] = rain

except:

pass

try:

time_temp = temp_df.loc[time]

temp_arr = time_temp[['latitude','longitude']].to_dict('records')

closest_temp_point = closest(temp_arr, v)

temp = time_temp[time_temp['latitude']==closest_temp_point['latitude']]['average temp (deg C)'][0]

main_df.at[i, 'temp'] = temp

except:

pass

try:

time_soil_temp = soil_temp_df.loc[time]

soil_temp_arr = time_soil_temp[['latitude','longitude']].to_dict('records')

closest_soil_temp_point = closest(soil_temp_arr, v)

soil_temp = time_soil_temp[time_soil_temp['latitude']==closest_soil_temp_point['latitude']]['average temp (deg C)'][0]

main_df.at[i, 'soil_temp'] = soil_temp

except:

pass

try:

time_aerosol = aerosol_df.loc[time]

aerosol_arr = time_aerosol[['latitude','longitude']].to_dict('records')

closest_aerosol_point = closest(aerosol_arr, v)

optical_thickness = time_aerosol[time_aerosol['latitude']==closest_aerosol_point['latitude']]['optical thickness'][0]

transmission_percent = time_aerosol[time_aerosol['latitude']==closest_aerosol_point['latitude']]['transmission percent'][0]

main_df.at[i, 'optical_thickness'] = optical_thickness

main_df.at[i, 'transmission_percent'] = transmission_percent

except:

pass

main_df.head()

# In[13]:

# Checking nan again as there may be some points with no data of that year so those particular entries will be nan.

main_df.isnull().sum()

# In[14]:

# Dropping nan containg rows...

main_df = main_df.dropna()

main_df.isnull().sum()

# In[15]:

# Calculating mean and stdv for each parameter...

temp_mean = np.mean(main_df['temp'])

temp_stdv = np.std(main_df['temp'])

soil_temp_mean = np.mean(main_df['soil_temp'])

soil_temp_stdv = np.std(main_df['soil_temp'])

rain_mean = np.mean(main_df['rain'])

rain_stdv = np.std(main_df['rain'])

optical_thickness_mean = np.mean(main_df['optical_thickness'])

optical_thickness_stdv = np.std(main_df['optical_thickness'])

transmission_percent_mean = np.mean(main_df['transmission_percent'])

transmission_percent_stdv = np.std(main_df['transmission_percent'])

# In[16]:

# Calculating range in which 70 percent of species will occur according to Haversine Formula

temp_range = [temp_mean - 1.5 * temp_stdv, temp_mean + 1.5 * temp_stdv]

soil_temp_range = [soil_temp_mean - 1.5 * soil_temp_stdv, soil_temp_mean + 1.5 * soil_temp_stdv]

rain_range = [rain_mean - 1.5 * rain_stdv, rain_mean + 1.5 * rain_stdv]

optical_thickness_range = [optical_thickness_mean - 1.5 * optical_thickness_stdv, optical_thickness_mean + 1.5 * optical_thickness_stdv]

transmission_percent_range = [transmission_percent_mean - 1.5 * transmission_percent_stdv, transmission_percent_mean + 1.5 * transmission_percent_stdv]

print('Temprature range --- from ' + str(temp_range[0]) + ' to ' + str(temp_range[1]))

print('Soil Temprature range --- from ' + str(soil_temp_range[0]) + ' to ' + str(soil_temp_range[1]))

print('Rain range --- from ' + str(rain_range[0]) + ' to ' + str(rain_range[1]))

print('Optical Thickness range --- from ' + str(optical_thickness_range[0]) + ' to ' + str(optical_thickness_range[1]))

print('Transmission Percent range --- from ' + str(transmission_percent_range[0]) + ' to ' + str(transmission_percent_range[1]))

# In[17]:

# Plotting all the points on google map

import gmplot

latitude_list = np.array(main_df['decimalLatitude'])

longitude_list = np.array(main_df['decimalLongitude'])

gmap4 = gmplot.GoogleMapPlotter(30.3164945,

78.03219179999999, 13)

gmap4.scatter( latitude_list, longitude_list, '#FF0000', size = 40, marker = False )

gmap4.draw( "C:\\Users\\cmgupta159\\Desktop\\lomdi.html")

# In[18]:

# Importing libraries to plot graphs

import matplotlib.pyplot as plt

import seaborn as sns

# In[19]:

# Plotting fraction of Temprature

graph1 = sns.kdeplot(data=main_df['temp'], shade=True)

graph1.axvline(temp_range[0])

graph1.axvline(temp_range[1])

graph1.set_xlabel("Temprature")

graph1.set_ylabel("Fraction")

plt.text(29,.05,'mean - ' + str(round(temp_mean,2)))

plt.text(29,.045,'stdv - ' + str(round(temp_stdv,2)))

plt.savefig('kde_temp_lomdi.png')

plt.show()

# In[20]:

# Plotting fraction of Soil Temprature

graph2 = sns.kdeplot(data=main_df['soil_temp'], shade=True)

graph2.axvline(soil_temp_range[0])

graph2.axvline(soil_temp_range[1])

plt.xlabel("Soil Temprature")

plt.ylabel("Fraction")

plt.text(29,.04,'mean - ' + str(round(soil_temp_mean,2)))

plt.text(29,.035,'stdv - ' + str(round(soil_temp_stdv,2)))

plt.savefig('soil_temp_lomdi.png')

plt.show()

# In[21]:

# Plotting fraction of Optical Thickness

graph = sns.kdeplot(data=main_df['optical_thickness'], shade=True)

graph.axvline(optical_thickness_range[0])

graph.axvline(optical_thickness_range[1])

plt.xlabel("Optical Thickness")

plt.ylabel("Fraction")

plt.text(6,3.1,'mean - ' + str(round(optical_thickness_mean,2)))

plt.text(6,3.5,'stdv - ' + str(round(optical_thickness_stdv,2)))

plt.savefig('optical_lomdi.png')

plt.show()

# In[22]:

# Plotting fraction of Transmission Percent

graph = sns.kdeplot(data=main_df['transmission_percent'], shade=True)

graph.axvline(transmission_percent_range[0])

graph.axvline(transmission_percent_range[1])

plt.xlabel("Transmission Percent")

plt.ylabel("Fraction")

plt.text(0,.05,'mean - ' + str(round(transmission_percent_mean,2)))

plt.text(0,.055,'stdv - ' + str(round(transmission_percent_stdv,2)))

plt.savefig('trans_lomdi.png')

plt.show()

# In[23]:

plt.hist(main_df['temp'])

plt.xlabel("Temprature")

plt.ylabel("No. of Occurrences in Data")

plt.text(25,3000,'mean - ' + str(round(temp_mean,2)))

plt.text(25,2700,'stdv - ' + str(round(temp_stdv,2)))

plt.savefig('hist_temp_lomdi.png')

#!/usr/bin/env python

# coding: utf-8

# In[1]:

# Importing libraries

import pandas as pd

import numpy as np

# In[2]:

# Importing data from which graph is made

df = pd.read_csv('vege.csv',header=None)

# Making a copy

df_copy = df.copy()

df.head()

# In[3]:

# Replacing Ocean area with 0 and land area with 100...

for i in range (df.shape[0]):

for j in range (df.shape[1]):

if df[j][i] == 99999:

df_copy[j][i] =0

else:

df_copy[j][i] =100

# In[4]:

arr = np.array(df_copy)

# In[5]:

# Saving the map

import matplotlib.pyplot as plt

plt.imsave('map0.25.png', arr)

# In[6]:

# Replacing Ocean area with nan...

for i in range (df.shape[0]):

for j in range (df.shape[1]):

if df[j][i] == 99999:

df[j][i] =np.nan

else:

df[j][i] =1

df.head()

# In[7]:

df.to_csv('helper.csv',index=None)

#!/usr/bin/env python

# coding: utf-8

# In[1]:

# Importing Libraries

from PIL import Image

import numpy as np

import pandas as pd

# In[2]:

# Importing Images

img = Image.open("map0.25.png")

numpydata = np.asarray(img)

arr = numpydata.copy()

numpydata

# In[3]:

# Importing vegetation data downloaded from https://neo.sci.gsfc.nasa.gov/

vege_df = pd.read_csv('vege.csv',header=None)

vege_df.head()

# In[4]:

# Importing rain data downloaded from https://neo.sci.gsfc.nasa.gov/

rain_df = pd.read_csv('rain.csv',header=None)

rain_df.head()

# In[5]:

# Importing temprature data downloaded from https://neo.sci.gsfc.nasa.gov/

temp_df = pd.read_csv('temp.csv',header=None)

temp_df.head()

# In[6]:

# Importing optical data downloaded from https://neo.sci.gsfc.nasa.gov/

optical_df = pd.read_csv('optical.csv',header=None)

optical_df.head()

# In[7]:

helper_df = pd.read_csv('helper.csv',header=None)

rain_land = helper_df*rain_df

optical_land = helper_df*optical_df

temp_land = helper_df*temp_df

vege_land = helper_df*vege_df

# In[8]:

# Getting points with all conditions favourable

for i in range (helper_df.shape[0]):

for j in range (helper_df.shape[1]):

try:

if 0.5 < vege_land[j][i] and 1.641749188574094 < temp_land[j][i] < 26.505227476389237 and 0 < optical_land[j][i] < 0.5:

arr[i,j] = np.array([255,255,255,255])

except:

pass

# In[9]:

# Saving image

import matplotlib.pyplot as plt

plt.imsave('inter_map.png', arr)