Graph Design - Exercise / Cameron Ballard

data = d3.csv(inspectionsURL, row => {

const date = d3.timeParse("%Y-%m-%d")(row["INSPECTION DATE"]);

const d = {

restaurantID: row["CAMIS"],

boro: row["BORO"],

zip: row["ZIPCODE"],

cuisine: row["CUISINE DESCRIPTION"],

date: date,

violationCode: row["VIOLATION CODE"],

score: +row["SCORE"],

grade: row["GRADE"],

inspectionID: row["INSPECTION ID"]

};

return d;

})

function removeDuplicates(array, key) {

let lookup = {};

let newarray = [];

for (let i in array) {

var inspID = array[i]['inspectionID'];

lookup[inspID] = array[i];

}

for(let i in lookup) {

newarray.push(lookup[i]);

}

return newarray;

}

//Function to make bar chart

function makeGradeBar(data, title, xfield, yfield) {

return vl.markBar()

.title(title)

.data(data)

.encode(

vl.x().fieldQ(xfield),

vl.y().fieldN(yfield).sort(vl.field(yfield).order('ascending')),

)

}

// Filter out repeated inspections

deduplicatedData = removeDuplicates(data, 'inspectionID')

{

// Find most common cuisines

const cuisineCount = d3.rollup(deduplicatedData,

v => v.length,

d => d.cuisine)

const cuisineCountArray = Array.from(cuisineCount,

([cuisine, count]) => ({cuisine, count}))

//return cuisineCountArray.sort((a,b) => d3.descending(a.count, b.count)).slice(0,5)

return cuisineCountArray.sort((a,b) => d3.descending(a.count, b.count)).slice(0,5)

}

{

//Filter out uncommon cuisines type of cuisine

const popularCuisines = ["American", "Mexican", "Pizza", "Café/Coffee/Tea", "Chinese"]

const mostCommon = deduplicatedData.filter(obj => popularCuisines.includes(obj.cuisine))

//Change weird grades to other

const grades = ["A", "B", "C"]

for(let i in deduplicatedData) {

if (!grades.includes(deduplicatedData[i].grade)) {

deduplicatedData[i].grade = "Other"

}

const americanCuisine = mostCommon.filter(obj => obj.cuisine == 'American')

const americanGradeCount = Array.from(d3.rollup(americanCuisine,

v => v.length,

d => d.grade),

([grade, count]) => ({grade, count}))

const mexicanCuisine = mostCommon.filter(obj => obj.cuisine == 'Mexican')

const mexicanGradeCount = Array.from(d3.rollup(mexicanCuisine,

v => v.length,

d => d.grade),

([grade, count]) => ({grade, count}))

const chineseCuisine = mostCommon.filter(obj => obj.cuisine == 'Chinese')

const chineseGradeCount = Array.from(d3.rollup(chineseCuisine,

v => v.length,

d => d.grade),

([grade, count]) => ({grade, count}))

const pizzaCuisine = mostCommon.filter(obj => obj.cuisine == 'Pizza')

const pizzaGradeCount = Array.from(d3.rollup(pizzaCuisine,

v => v.length,

d => d.grade),

([grade, count]) => ({grade, count}))

const cafeCuisine = mostCommon.filter(obj => obj.cuisine == 'Café/Coffee/Tea')

const cafeGradeCount = Array.from(d3.rollup(cafeCuisine,

v => v.length,

d => d.grade),

([grade, count]) => ({grade, count}))

return vl.vconcat(

makeGradeBar(americanGradeCount, "Health inspection grade distribution for American cuisine", "count", "grade"),

makeGradeBar(mexicanGradeCount, "Health inspection grade distribution for Mexican cuisine", "count", "grade"),

makeGradeBar(chineseGradeCount, "Health inspection grade distribution for Chinese cuisine", "count", "grade"),

makeGradeBar(pizzaGradeCount, "Health inspection grade distribution for Pizza cuisine", "count", "grade"),

makeGradeBar(cafeGradeCount, "Health inspection grade distribution for Cafe cuisine", "count", "grade"), ).render()

//return groupedArray

}

function makeLineChart(data, title, xfield, yfield) {

vl.markLine()

.data(data)

.title(title)

.encode(

vl.x().fieldT(xfield),

vl.y().fieldQ(yfield)

)

}

{

var monthFormat = d3.timeFormat('%Y-%m')

const boroughGrouped = d3.group(deduplicatedData, d => d.boro)

const BronxInspectionsByTime = Array.from(d3.rollup(boroughGrouped.get("Bronx"),

v => v.length,

d => monthFormat(d.date)),