Hi, I'm Shivanshu Pandey

# Crime Mapping and Analysis using Python and Folium
# This script reads crime data from a CSV file, processes it, and generates an interactive map.

import pandas as pd
import folium
from folium.plugins import HeatMap, MarkerCluster

# 1. Load the dataset (replace 'crime_data.csv' with your file)
# The CSV should have 'Latitude' and 'Longitude' columns.
try:
    df = pd.read_csv('crime_data.csv')
    df.dropna(subset=['Latitude', 'Longitude'], inplace=True)
except FileNotFoundError:
    print("Error: Creating dummy data for demonstration.")
    data = {'Latitude': [28.61, 28.53, 28.65, 28.70], 'Longitude': [77.20, 77.22, 77.24, 77.10], 'CrimeType': ['Theft', 'Assault', 'Burglary', 'Robbery']}
    df = pd.DataFrame(data)

# 3. Initialize the map
map_center = [df['Latitude'].mean(), df['Longitude'].mean()]
crime_map = folium.Map(location=map_center, zoom_start=11, tiles="CartoDB dark_matter")

# 4. Create Feature Groups and Layers
heatmap_layer = folium.FeatureGroup(name='Crime Heatmap')
HeatMap([[row['Latitude'], row['Longitude']] for index, row in df.iterrows()], radius=15).add_to(heatmap_layer)

marker_cluster_layer = folium.FeatureGroup(name='Individual Incidents')
marker_cluster = MarkerCluster().add_to(marker_cluster_layer)
for idx, row in df.iterrows():
    popup_text = f"Crime: {row.get('CrimeType', 'N/A')}"
    folium.Marker(location=[row['Latitude'], row['Longitude']], popup=popup_text).add_to(marker_cluster)

# 5. Add layers to map
heatmap_layer.add_to(crime_map)
marker_cluster_layer.add_to(crime_map)
folium.LayerControl().add_to(crime_map)

# 6. Save the map
crime_map.save('crime_map.html')
                

This project uses p5.js for drawing and webcam access, and ml5.js for the pre-trained PoseNet model. The following is a simplified example of the core logic in a `sketch.js` file.

// Posture Detection using p5.js and ml5.js
let video;
let poseNet;
let poses = [];
let status = 'Good';

function setup() {
  createCanvas(640, 480);
  video = createCapture(VIDEO);
  video.size(width, height);
  poseNet = ml5.poseNet(video, () => console.log('Model Loaded!'));
  poseNet.on('pose', (results) => {
    poses = results;
    checkPosture();
  });
  video.hide();
}

function draw() {
  image(video, 0, 0, width, height);
  drawKeypoints();
  fill(status === 'Good' ? '#22c55e' : '#ef4444');
  textSize(32);
  textAlign(CENTER, CENTER);
  text(`${status} Posture`, width / 2, 50);
}

function drawKeypoints() {
  for (let pose of poses) {
    for (let keypoint of pose.pose.keypoints) {
      if (keypoint.score > 0.2) {
        fill(56, 189, 248);
        noStroke();
        ellipse(keypoint.position.x, keypoint.position.y, 10, 10);
      }
    }
  }
}

function checkPosture() {
    if (poses.length > 0) {
        const { nose, leftShoulder, rightShoulder } = poses[0].pose.keypoints.reduce((acc, kp) => ({...acc, [kp.part]: kp }), {});
        if (nose.score > 0.5 && leftShoulder.score > 0.5 && rightShoulder.score > 0.5) {
            const shoulderY = (leftShoulder.position.y + rightShoulder.position.y) / 2;
            status = (nose.position.y > shoulderY + 20) ? 'Bad' : 'Good';
        }
    }
}
                

This project uses ReactJS for the frontend and interacts with the Gemini API for chat functionality. Below is a simplified example of the main chat component.

ReactJS Component (`Chat.jsx`)

import React, { useState } from 'react';
import { runChat } from './api/gemini'; // Assumed API call function

function Chat() {
  const [prompt, setPrompt] = useState('');
  const [messages, setMessages] = useState([]);
  const [loading, setLoading] = useState(false);

  const handleSubmit = async (e) => {
    e.preventDefault();
    if (!prompt) return;

    const userMessage = { from: 'user', text: prompt };
    setMessages(prev => [...prev, userMessage]);
    setLoading(true);
    
    try {
        const aiResponse = await runChat(prompt);
        const aiMessage = { from: 'ai', text: aiResponse };
        setMessages(prev => [...prev, userMessage, aiMessage]);
    } catch (error) {
        console.error("API Error:", error);
        const errorMessage = { from: 'ai', text: 'Sorry, something went wrong.' };
        setMessages(prev => [...prev, userMessage, errorMessage]);
    } finally {
        setLoading(false);
        setPrompt('');
    }
  };

  return (
    <div className="chat-container">
      <div className="message-list">
        {messages.map((msg, index) => (
          <div key={index} className={`message ${msg.from}`}>
            <p>{msg.text}</p>
          </div>
        ))}
        {loading && <div className="message ai">Thinking...</div>}
      </div>
      <form onSubmit={handleSubmit} className="input-form">
        <input type="text" value={prompt} onChange={(e) => setPrompt(e.target.value)} placeholder="Enter a prompt here" />
        <button type="submit" disabled={loading}>Send</button>
      </form>
    </div>
  );
}
export default Chat;
                

This project was developed using Power BI to connect to a live weather REST API, transforming the JSON response into an interactive dashboard.

Process in Power Query:

• API Connection: Used the `Web.Contents` function in Power Query to connect to the weather API endpoint, passing a city name as a parameter.
• JSON Parsing: The JSON response from the API was parsed within Power Query to extract relevant data points like temperature, humidity, wind speed, and forecast details.
• Data Transformation: Cleaned and transformed the data by expanding records, converting data types (e.g., Unix timestamps to DateTime), and unpivoting columns to create a tidy dataset suitable for analysis.

Process in Power BI (DAX & Visualization):

• Data Modeling: Established a simple data model to handle current weather and forecast data.
• DAX Measures: Wrote DAX (Data Analysis Expressions) formulas to create key metrics. Example: Avg Temperature = AVERAGE('Weather'[Temperature]).
• Visualization: Built the dashboard using various visuals:
  • Cards to display current temperature and humidity.
  • Line charts to show temperature trends over a 5-day forecast.
  • Gauges to visualize wind speed.
  • Slicers to allow users to dynamically select a city to view weather for.