AeroViz 0.1.0__py3-none-any.whl

AeroViz/plot/templates/koschmieder.py

@@ -0,0 +1,156 @@
+from typing import Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from scipy.optimize import curve_fit
+
+from AeroViz.plot.utils import *
+
+__all__ = ['koschmieder']
+
+
+@set_figure(fs=12)
+def koschmieder(df: pd.DataFrame,
+				y: Literal['Vis_Naked', 'Vis_LPV'],
+				function: Literal['log', 'reciprocal'] = 'log',
+				ax: Axes | None = None,
+				**kwargs) -> tuple[Figure, Axes]:
+	# x = Visibility, y = Extinction, log-log fit!!
+	def _log_fit(x, y, func=lambda x, a: -x + a):
+		x_log = np.log(x)
+		y_log = np.log(y)
+
+		popt, pcov = curve_fit(func, x_log, y_log)
+
+		residuals = y_log - func(x_log, *popt)
+		ss_res = np.sum(residuals ** 2)
+		ss_total = np.sum((y_log - np.mean(y_log)) ** 2)
+		r_squared = 1 - (ss_res / ss_total)
+		print(f'Const_Log = {popt[0].round(3)}')
+		print(f'Const = {np.exp(popt)[0].round(3)}')
+		print(f'R^2 = {r_squared.round(3)}')
+		return np.exp(popt)[0], pcov
+
+	def _reciprocal_fit(x, y, func=lambda x, a, b: a / (x ** b)):
+		popt, pcov = curve_fit(func, x, y)
+
+		residuals = y - func(x, *popt)
+		ss_res = np.sum(residuals ** 2)
+		ss_total = np.sum((y - np.mean(y)) ** 2)
+		r_squared = 1 - (ss_res / ss_total)
+		print(f'Const = {popt.round(3)}')
+		print(f'  R^2 = {r_squared.round(3)}')
+		return popt, pcov
+
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	_df1 = df[['Extinction', 'ExtinctionByGas', y]].dropna().copy()
+	_df2 = df[['total_ext_dry', 'ExtinctionByGas', y]].dropna().copy()
+
+	x_data1 = _df1[y]
+	y_data1 = _df1['Extinction'] + _df1['ExtinctionByGas']
+
+	x_data2 = _df2[y]
+	y_data2 = _df2['total_ext_dry'] + _df2['ExtinctionByGas']
+
+	para_coeff = []
+	boxcolors = ['#3f83bf', '#a5bf6b']
+
+	for i, (df_, x_data, y_data) in enumerate(zip([_df1, _df2], [x_data1, x_data2], [y_data1, y_data2])):
+		df_['Total_Ext'] = y_data
+
+		if y == 'Vis_Naked':
+			df_grp = df_.groupby(f'{y}')
+
+			vals, median_vals, vis = [], [], []
+			for j, (name, subdf) in enumerate(df_grp):
+				if len(subdf['Total_Ext'].dropna()) > 20:
+					vis.append('{:.0f}'.format(name))
+					vals.append(subdf['Total_Ext'].dropna().values)
+					median_vals.append(subdf['Total_Ext'].dropna().median())
+
+			plt.boxplot(vals, labels=vis, positions=np.array(vis, dtype='int'), widths=0.4,
+						showfliers=False, showmeans=True, meanline=False, patch_artist=True,
+						boxprops=dict(facecolor=boxcolors[i], alpha=.7),
+						meanprops=dict(marker='o', markerfacecolor='white', markeredgecolor='k', markersize=4),
+						medianprops=dict(color='#000000', ls='-'))
+
+			plt.scatter(x_data, y_data, marker='.', s=10, facecolor='white', edgecolor=boxcolors[i], alpha=0.1)
+
+		if y == 'Vis_LPV':
+			bins = np.linspace(0, 70, 36)
+			wid = (bins + (bins[1] - bins[0]) / 2)[0:-1]
+
+			df_[f'{x_data.name}' + '_bins'] = pd.cut(x=x_data, bins=bins, labels=wid)
+
+			grouped = df_.groupby(f'{x_data.name}' + '_bins', observed=False)
+
+			vals, median_vals, vis = [], [], []
+			for j, (name, subdf) in enumerate(grouped):
+				if len(subdf['Total_Ext'].dropna()) > 20:
+					vis.append('{:.1f}'.format(name))
+					vals.append(subdf['Total_Ext'].dropna().values)
+					median_vals.append(subdf['Total_Ext'].dropna().mean())
+
+			plt.boxplot(vals, labels=vis, positions=np.array(vis, dtype='float'), widths=(bins[1] - bins[0]) / 2.5,
+						showfliers=False, showmeans=True, meanline=False, patch_artist=True,
+						boxprops=dict(facecolor=boxcolors[i], alpha=.7),
+						meanprops=dict(marker='o', markerfacecolor='white', markeredgecolor='k', markersize=4),
+						medianprops=dict(color='#000000', ls='-'))
+
+			plt.scatter(x_data, y_data, marker='.', s=10, facecolor='white', edgecolor=boxcolors[i], alpha=0.1)
+
+		# fit curve
+		_x = np.array(vis, dtype='float')
+		_y = np.array(median_vals, dtype='float')
+
+		if function == 'log':
+			func = lambda x, a: a / x
+			coeff, pcov = _log_fit(_x, _y)
+
+		else:
+			func = lambda x, a, b: a / (x ** b)
+			coeff, pcov = _reciprocal_fit(_x, _y)
+
+		para_coeff.append(coeff)
+
+	# Plot lines (ref & Measurement)
+	x_fit = np.linspace(0.1, 70, 1000)
+
+	if function == 'log':
+		line1, = ax.plot(x_fit, func(x_fit, para_coeff[0]), c='b', lw=3)
+		line2, = ax.plot(x_fit, func(x_fit, para_coeff[1]), c='g', lw=3)
+
+		labels = ['Vis (km) = ' + f'{round(para_coeff[0])}' + ' / Ext (Dry Extinction)',
+				  'Vis (km) = ' + f'{round(para_coeff[1])}' + ' / Ext (Amb Extinction)']
+
+	else:
+		x_fit = np.linspace(0.1, 70, 1000)
+		line1, = ax.plot(x_fit, func(x_fit, *para_coeff[0]), c='b', lw=3)
+		line2, = ax.plot(x_fit, func(x_fit, *para_coeff[1]), c='g', lw=3)
+
+		labels = [f'Ext = ' + '{:.0f} / Vis ^ {:.3f}'.format(*para_coeff[0]) + ' (Dry Extinction)',
+				  f'Ext = ' + '{:.0f} / Vis ^ {:.3f}'.format(*para_coeff[1]) + ' (Amb Extinction)']
+
+	plt.legend(handles=[line1, line2], labels=labels, loc='upper right', prop=dict(size=10, weight='bold'),
+			   bbox_to_anchor=(0.99, 0.99))
+
+	plt.xticks(ticks=np.array(range(0, 51, 5)), labels=np.array(range(0, 51, 5)))
+	plt.xlim(0, 50)
+	plt.ylim(0, 700)
+	plt.title(r'$\bf Koschmieder\ relationship$')
+	plt.xlabel(f'{y} (km)')
+	plt.ylabel(r'$\bf Extinction\ coefficient\ (1/Mm)$')
+
+	plt.show()
+
+	return fig, ax
+
+
+if __name__ == '__main__':
+	from AeroViz.tools import DataBase
+
+	koschmieder(DataBase(), 'Vis_LPV', 'log')
+	# koschmieder(DataBase, 'Vis_Naked', 'reciprocal')

AeroViz/plot/templates/metal_heatmap.py

@@ -0,0 +1,57 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame, date_range
+from sklearn.preprocessing import StandardScaler
+
+from AeroViz.plot.utils import *
+
+
+def process_data(df):
+	# detected_limit = 0.0001
+	df = df.where(df >= 0.0001, np.nan)
+	# Normalize the data
+	df = DataFrame(StandardScaler().fit_transform(df), index=df.index, columns=df.columns)
+	# Remove outliers
+	df = df[(np.abs(df) < 6)]
+	# Interpolate the missing values
+	df = df.interpolate(method='linear')
+	# Smooth the data
+	df = df.rolling(window=3, min_periods=1).mean()
+
+	return df
+
+
+@set_figure(figsize=(12, 3), fs=6)
+def metal_heatmaps(df, major_freq='24h', minor_freq='12h', ax: Axes | None = None, title=None, **kwargs
+				   ) -> tuple[Figure, Axes]:
+	items = ['Al', 'Zr', 'Si', 'Ca', 'Ti', 'Mn', 'Fe', 'V', 'Cl', 'K',
+			 'Sr', 'Ba', 'Bi', 'Pd', 'Sn', 'Cr', 'W', 'Cu', 'Zn',
+			 'As', 'Co', 'Se', 'Br', 'Cd', 'Sb', 'In', 'Pb', 'Ni']
+
+	df = df[items]
+
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	sns.heatmap(df.T, vmax=3, cmap="jet", xticklabels=False, yticklabels=True,
+				cbar_kws={'label': 'Z score'})
+	ax.grid(color='gray', linestyle='-', linewidth=0.3)
+	# Set x-tick positions and labels
+	major_tick = date_range(start=df.index[0], end=df.index[-1], freq=major_freq)
+	minor_tick = date_range(start=df.index[0], end=df.index[-1], freq=minor_freq)
+
+	# Set the major and minor ticks
+	ax.set_xticks(ticks=[df.index.get_loc(t) for t in major_tick])
+	ax.set_xticks(ticks=[df.index.get_loc(t) for t in minor_tick], minor=True)
+	ax.set_xticklabels(major_tick.strftime('%F'))
+	ax.tick_params(axis='y', rotation=0)
+
+	ax.set_title(f"{title}", fontsize=10)
+	ax.set(xlabel='',
+		   ylabel='',
+		   )
+
+	plt.show()
+
+	return fig, ax

AeroViz/plot/templates/regression.py

@@ -0,0 +1,256 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from sklearn.linear_model import LinearRegression
+from tabulate import tabulate
+
+from AeroViz.plot.utils import *
+
+__all__ = [
+	'linear_regression',
+	'multiple_linear_regression',
+]
+
+
+def _linear_regression(x_array: np.ndarray,
+					   y_array: np.ndarray,
+					   columns: str | list[str] | None = None,
+					   positive: bool = True,
+					   fit_intercept: bool = True):
+	if len(x_array.shape) > 1 and x_array.shape[1] >= 2:
+		model = LinearRegression(positive=positive, fit_intercept=fit_intercept).fit(x_array, y_array)
+
+		coefficients = model.coef_[0].round(3)
+		intercept = model.intercept_[0].round(3) if fit_intercept else 'None'
+		r_square = model.score(x_array, y_array).round(3)
+		y_predict = model.predict(x_array)
+
+		equation = ' + '.join([f'{coeff:.3f} * {col}' for coeff, col in zip(coefficients, columns)])
+		equation = equation.replace(' + 0.000 * Const', '')  # Remove terms with coefficient 0
+
+		text = 'y = ' + str(equation) + '\n' + r'$\bf R^2 = $' + str(r_square)
+		tab = tabulate([[*coefficients, intercept, r_square]], headers=[*columns, 'intercept', 'R^2'], floatfmt=".3f",
+					   tablefmt="fancy_grid")
+		print('\n' + tab)
+
+		return text, y_predict, coefficients
+
+	else:
+		x_array = x_array.reshape(-1, 1)
+		y_array = y_array.reshape(-1, 1)
+
+		model = LinearRegression(positive=positive, fit_intercept=fit_intercept).fit(x_array, y_array)
+
+		slope = model.coef_[0][0].round(3)
+		intercept = model.intercept_[0].round(3) if fit_intercept else 'None'
+		r_square = model.score(x_array, y_array).round(3)
+		y_predict = model.predict(x_array)
+
+		text = np.poly1d([slope, intercept])
+		text = 'y = ' + str(text).replace('\n', "") + '\n' + r'$\bf R^2 = $' + str(r_square)
+
+		tab = tabulate([[slope, intercept, r_square]], headers=['slope', 'intercept', 'R^2'], floatfmt=".3f",
+					   tablefmt="fancy_grid")
+		print('\n' + tab)
+
+		return text, y_predict, slope
+
+
+@set_figure
+def linear_regression(df: pd.DataFrame,
+					  x: str | list[str],
+					  y: str | list[str],
+					  labels: str | list[str] = None,
+					  ax: Axes | None = None,
+					  diagonal=False,
+					  positive: bool = True,
+					  fit_intercept: bool = True,
+					  **kwargs
+					  ) -> tuple[Figure, Axes]:
+	"""
+	Create a scatter plot with multiple regression lines for the given data.
+
+	Parameters
+	----------
+	df : DataFrame
+		Input DataFrame containing the data.
+
+	x : str or list of str
+		Column name(s) for the x-axis variable(s).
+
+	y : str or list of str
+		Column name(s) for the y-axis variable(s).
+
+	labels : str or list of str, optional
+		Labels for the y-axis variable(s). If None, column names are used as labels. Default is None.
+
+	ax : AxesSubplot, optional
+		Matplotlib AxesSubplot to use for the plot. If None, a new subplot is created. Default is None.
+
+	diagonal : bool, optional
+		If True, a diagonal line (1:1 line) is added to the plot. Default is False.
+
+	positive : bool, optional
+	   Whether to let coefficient positive. Default is True.
+
+	fit_intercept: bool, optional
+		Whether to fit intercept. Default is True.
+
+	**kwargs
+		Additional keyword arguments to customize the plot.
+
+	Returns
+	-------
+	AxesSubplot
+		Matplotlib AxesSubplot containing the scatter plot.
+
+	Notes
+	-----
+	- The function creates a scatter plot with the option to include multiple regression lines.
+	- If regression is True, regression lines are fitted for each y variable.
+	- Additional customization can be done using the **kwargs.
+
+	Example
+	-------
+	>>> linear_regression(df, x='X', y=['Y1', 'Y2'], labels=['Label1', 'Label2'],
+	...                      regression=True, diagonal=True, xlim=(0, 10), ylim=(0, 20),
+	...                      xlabel="X-axis", ylabel="Y-axis", title="Scatter Plot with Regressions")
+	"""
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	if not isinstance(x, str):
+		x = x[0]
+
+	if not isinstance(y, list):
+		y = [y]
+
+	if labels is None:
+		labels = y
+
+	df = df.dropna(subset=[x, *y])
+	x_array = df[[x]].to_numpy()
+
+	color_cycle = Color.linecolor
+
+	handles, text_list = [], []
+
+	for i, y_var in enumerate(y):
+		y_array = df[[y_var]].to_numpy()
+
+		color = color_cycle[i % len(color_cycle)]
+
+		scatter = ax.scatter(x_array, y_array, s=25, color=color['face'], edgecolors=color['edge'], alpha=0.8,
+							 label=labels[i])
+		handles.append(scatter)
+
+		text, y_predict, slope = _linear_regression(x_array, y_array,
+													columns=labels[i],
+													positive=positive,
+													fit_intercept=fit_intercept)
+
+		text_list.append(f'{labels[i]}: {text}')
+		plt.plot(x_array, y_predict, linewidth=3, color=color['line'], alpha=1, zorder=3)
+
+	ax.set(xlim=kwargs.get('xlim'), ylim=kwargs.get('ylim'), xlabel=Unit(x), ylabel=Unit(y[0]),
+		   title=kwargs.get('title'))
+
+	# Add regression info to the legend
+	leg = plt.legend(handles=handles, labels=text_list, loc='upper left', prop={'weight': 'bold', 'size': 10})
+
+	for text, color in zip(leg.get_texts(), [color['line'] for color in color_cycle]):
+		text.set_color(color)
+
+	if diagonal:
+		ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
+		plt.text(0.97, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
+
+	plt.show()
+
+	return fig, ax
+
+
+@set_figure
+def multiple_linear_regression(df: pd.DataFrame,
+							   x: str | list[str],
+							   y: str | list[str],
+							   labels: str | list[str] = None,
+							   ax: Axes | None = None,
+							   diagonal=False,
+							   positive: bool = True,
+							   fit_intercept: bool = True,
+							   **kwargs
+							   ) -> tuple[Figure, Axes]:
+	"""
+	Perform multiple linear regression analysis and plot the results.
+
+	Parameters
+	----------
+	df : pandas.DataFrame
+	   Input DataFrame containing the data.
+
+	x : str or list of str
+	   Column name(s) for the independent variable(s). Can be a single string or a list of strings.
+
+	y : str or list of str
+	   Column name(s) for the dependent variable(s). Can be a single string or a list of strings.
+
+	labels : str or list of str, optional
+	   Labels for the dependent variable(s). If None, column names are used as labels. Default is None.
+
+	ax : matplotlib.axes.Axes or None, optional
+	   Matplotlib Axes object to use for the plot. If None, a new subplot is created. Default is None.
+
+	diagonal : bool, optional
+	   Whether to include a diagonal line (1:1 line) in the plot. Default is False.
+
+	positive : bool, optional
+	   Whether to let coefficient positive. Default is True.
+
+	fit_intercept: bool, optional
+		Whether to fit intercept. Default is True.
+
+	**kwargs
+	   Additional keyword arguments to customize the plot.
+
+	Returns
+	-------
+	matplotlib.axes.Axes
+	   Matplotlib Axes object containing the regression plot.
+
+	Notes
+	-----
+	This function performs multiple linear regression analysis using the input DataFrame.
+	It supports multiple independent variables and can plot the regression results.
+
+	Example
+	-------
+	>>> multiple_linear_regression(df, x=['X1', 'X2'], y='Y', labels=['Y1', 'Y2'],
+	...                             diagonal=True, add_constant=True,
+	...                             xlabel="X-axis", ylabel="Y-axis", title="Multiple Linear Regression Plot")
+	"""
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	if not isinstance(x, list):
+		x = [x]
+
+	if not isinstance(y, str):
+		y = y[0]
+
+	if labels is None:
+		labels = x
+
+	df = df[[*x, y]].dropna()
+	x_array = df[[*x]].to_numpy()
+	y_array = df[[y]].to_numpy()
+
+	text, y_predict, coefficients = _linear_regression(x_array, y_array,
+													   columns=labels,
+													   positive=positive,
+													   fit_intercept=fit_intercept)
+
+	df = pd.DataFrame(np.concatenate([y_array, y_predict], axis=1), columns=['y_actual', 'y_predict'])
+
+	linear_regression(df, x='y_actual', y='y_predict', ax=ax, regression=True, diagonal=diagonal)
+
+	return fig, ax

AeroViz/plot/templates/scatter.py

@@ -0,0 +1,130 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib.colors import Normalize
+from matplotlib.pyplot import Figure, Axes
+from matplotlib.ticker import ScalarFormatter
+
+from AeroViz.plot.templates.regression import _linear_regression
+from AeroViz.plot.utils import *
+
+__all__ = ['scatter']
+
+
+@set_figure
+def scatter(df: pd.DataFrame,
+			x: str,
+			y: str,
+			c: str | None = None,
+			s: str | None = None,
+			cmap='jet',
+			regression=False,
+			diagonal=False,
+			box=False,
+			ax: Axes | None = None,
+			**kwargs) -> tuple[Figure, Axes]:
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	if c is not None and s is not None:
+		df_ = df.dropna(subset=[x, y, c, s]).copy()
+		x_data, y_data, c_data, s_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[c].to_numpy(), df_[s].to_numpy()
+
+		scatter = ax.scatter(x_data, y_data, c=c_data,
+							 norm=Normalize(vmin=np.percentile(c_data, 10), vmax=np.percentile(c_data, 90)),
+							 cmap=cmap, s=50 * (s_data / s_data.max()) ** 1.5, alpha=0.7, edgecolors=None)
+		colorbar = True
+
+		dot = np.linspace(s_data.min(), s_data.max(), 6).round(-1)
+
+		for dott in dot[1:-1]:
+			plt.scatter([], [], c='k', alpha=0.8, s=50 * (dott / s_data.max()) ** 1.5, label='{:.0f}'.format(dott))
+
+		plt.legend(title=Unit(s))
+
+	elif c is not None:
+		df_ = df.dropna(subset=[x, y, c]).copy()
+		x_data, y_data, c_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[c].to_numpy()
+
+		scatter = ax.scatter(x_data, y_data, c=c_data, vmin=c_data.min(), vmax=np.percentile(c_data, 90), cmap=cmap,
+							 alpha=0.7,
+							 edgecolors=None)
+		colorbar = True
+
+	elif s is not None:
+		df_ = df.dropna(subset=[x, y, s]).copy()
+		x_data, y_data, s_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[s].to_numpy()
+
+		scatter = ax.scatter(x_data, y_data, s=50 * (s_data / s_data.max()) ** 1.5, color='#7a97c9', alpha=0.7,
+							 edgecolors='white')
+		colorbar = False
+
+		# dealing
+		dot = np.linspace(s_data.min(), s_data.max(), 6).round(-1)
+
+		for dott in dot[1:-1]:
+			plt.scatter([], [], c='k', alpha=0.8, s=50 * (dott / s_data.max()) ** 1.5, label='{:.0f}'.format(dott))
+
+		plt.legend(title=Unit(s))
+
+	else:
+		df_ = df.dropna(subset=[x, y]).copy()
+		x_data, y_data = df_[x].to_numpy(), df_[y].to_numpy()
+
+		scatter = ax.scatter(x_data, y_data, s=30, color='#7a97c9', alpha=0.7, edgecolors='white')
+		colorbar = False
+
+	xlim = kwargs.get('xlim', (x_data.min(), x_data.max()))
+	ylim = kwargs.get('ylim', (y_data.min(), y_data.max()))
+	xlabel = kwargs.get('xlabel', Unit(x))
+	ylabel = kwargs.get('ylabel', Unit(y))
+	title = kwargs.get('title', '')
+	ax.set(xlim=xlim, ylim=ylim, xlabel=xlabel, ylabel=ylabel, title=title)
+
+	# color_bar
+	if colorbar:
+		color_bar = plt.colorbar(scatter, extend='both')
+		color_bar.set_label(label=Unit(c), size=14)
+
+	if regression:
+		text, y_predict, slope = _linear_regression(x_data, y_data)
+		plt.plot(x_data, y_predict, linewidth=3, color=sns.xkcd_rgb["denim blue"], alpha=1, zorder=3)
+
+		plt.text(0.05, 0.95, f'{text}', fontdict={'weight': 'bold'}, color=sns.xkcd_rgb["denim blue"],
+				 ha='left', va='top', transform=ax.transAxes)
+
+	if diagonal:
+		ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
+		plt.text(0.91, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
+
+	if box:
+		bins = np.linspace(x_data.min(), x_data.max(), 11, endpoint=True)
+		wid = (bins + (bins[1] - bins[0]) / 2)[0:-1]
+
+		df[x + '_bin'] = pd.cut(x=x_data, bins=bins, labels=wid)
+
+		group = x + '_bin'
+		column = y
+		grouped = df.groupby(group, observed=False)
+
+		names, vals = [], []
+
+		for i, (name, subdf) in enumerate(grouped):
+			names.append('{:.0f}'.format(name))
+			vals.append(subdf[column].dropna().values)
+
+		plt.boxplot(vals, labels=names, positions=wid, widths=(bins[1] - bins[0]) / 3,
+					showfliers=False, showmeans=True, meanline=True, patch_artist=True,
+					boxprops=dict(facecolor='#f2c872', alpha=.7),
+					meanprops=dict(color='#000000', ls='none'),
+					medianprops=dict(ls='-', color='#000000'))
+
+		plt.xlim(x_data.min(), x_data.max())
+		ax.set_xticks(bins, labels=bins.astype(int))
+
+	ax.xaxis.set_major_formatter(ScalarFormatter())
+	ax.yaxis.set_major_formatter(ScalarFormatter())
+
+	plt.show()
+
+	return fig, ax