GetStyled | 268 followers on LinkedIn. Beauty &amp; Styling Marketplace | GetStyled is India&#x27;s leading curated styling platform for fashion and beauty services. Our mission is to democratize access to fashion stylists and makeup artists and support local service providers while also working towards ...

GetStyled | LinkedIn

Book India&#x27;s most in-demand Makeup Artists, Fashion Stylists &amp; Personal Shoppers.

GetStyled | Makeup Artists, Fashion Stylists & Personal Shoppers ...

&quot;Wardo is a fashion &amp; beauty styling platform aiming to help the 1 billion+ of online shoppers globally that struggle with buying clothes, accessories &amp; makeup online. Using our mobile app, users can get personalised fashion &amp; beauty advice from industry experts, influencers or even their friends.

Wardo (GetStyled) Company Profile, information, investors, valuation ...

get into your shade of nude · spring brunch vibes only

Style Stage Boutique

Shopping destination for fashion online. Our mission is to provide you with the latest fashion and accessories sourced from the U.S.

Get Styled - Quality clothing at affordable prices – GetStyled.org

GetStyled can help you. Our platform matches you to top experts for remote &amp; in-person jobs,. From influencers to professionals to celebrity stylists, find the talent you want with the skills you need in minutes, not days. **Our network of experienced experts specialise in over 25+ services ...

GetStyled: Book MUAs, Stylists – Apps on Google Play

Browse personal stylists with GetStyled. Book our fashion stylists and get outfit planning, wardrobe detox, and style makeover services in Delhi NCR.

GetStyled - Book Your Personal Stylists & Fashion Consultants

Read writing from GetStyled on Medium. GetStyled is your own personal virtual stylist that custom generates outfits that are best suited for YOU. Every day, GetStyled and thousands of other voices read, write, and share important stories on Medium.

GetStyled – Medium

Personal Style packages for Special Occasion Styling personal stylist in NYC

Get Styled! — Style IngeNEWity

GetStyled is the best wedding styling service provider in Delhi/NCR. We provide the best wedding styling artist to make you look your best in your wedding.

Best Wedding Styling Artist in Delhi/NCR | GetStyled

Get-styled

Facebook

At GetStyled, we are using styling to help bring out the best in people

GetStyled

In certain scenarios, there is a need to fetch styles from the backend. This could be particularly relevant when dealing with private themes or implementing white-label solutions. The backend, in this context, acts as the source of style settings, drawing them either from a database or a . The specific data source may vary, but the process remains consistent. YAML file In this article, I'm going to demystify the art of setting styles for our UI. Let's assume that the UI is constructed with , although the principles we're about to delve into are versatile and can be applied regardless of the framework you choose, or even if you opt for a framework-less approach. Angular To start, let's create a service: @Injectable()
export class StylesService {

 defaultStyles: Record<string, string> = {
 primary: 'green',
 secondary: 'blue',
 };

 constructor(
 private readonly http: HttpClient,
 @Inject(DOCUMENT) private readonly document: Document,
 ) {}

 ...
} We've established default styles for both primary and secondary colors. To achieve our goals, we'll be making use of HttpClient and Document. Let's proceed by implementing some essential methods. The initial method's purpose is to retrieve styles from the backend and seamlessly integrate them into the Document Object Model (DOM): setStyles(): void {
 this.http.get('/styles').subscribe((styles: Record<string, string>) => {
 styles = {...this.defaultStyles, ...styles};

 localStorage.setItem('currentStyles', JSON.stringify(styles));

 this.document.documentElement.style.setProperty('--primary-color', styles.primary || '');
 this.document.documentElement.style.setProperty('--secondary-color', styles.secondary || '');
 });
 } Initially, we begin by redefining the default styles according to our specific requirements. Subsequently, we save the existing styles in Local Storage, making them accessible for use within our JavaScript code. Concurrently, we establish CSS variables for the Document element, which can be harnessed within our CSS code. The second method in our arsenal retrieves styles from Local Storage, allowing us to easily access and return them when needed: getStyles(): Record<string, string> {
 const styles = localStorage.getItem('currentStyles');

 if (styles) {
 return JSON.parse(styles) as Record<string, string>;
 }

 return null;
 } This method becomes a valuable tool that we can employ across various components of our project, ensuring consistency in style management throughout. If your project uses SCSS, this code performs translating CSS variables into SCSS variables: $primary-color: var(--primary-color, orange);
$default-secondary: var(--secondary-color, purple); Alternatively, if it better suits your project's needs, you can choose to use these styles as they are, without the need for translation into SCSS variables: a {
 color: var(--primary-color, #F69C00);
} The second parameter of the function comes into play when the variable doesn't exist. It acts as a fallback value, ensuring that your code remains robust even if the primary color variable is not defined. var() --primary-color In this article, we've explored the art of harnessing backend-powered styles for your user interface, using Angular as our framework of reference. We've learned how to retrieve and integrate styles from the backend into the , ensuring dynamic and flexible styling for our applications. Additionally, we've discussed storing and utilizing these styles efficiently, both in JavaScript and SCSS environments. DOM

Backend-Powered Styles for Your User Interface 

Until recently, developing geospatial apps beyond a 2D map required a comprehensive GIS (Geospatial Information System) service such as ArcGIS, Nokia Here, or Google Maps. While these APIs are powerful, they are also expensive, onerous to learn and lock the map developer to a single solution. Fortunately, there are now a wealth of useful, open-source JavaScript tools for handling advanced cartography and geospatial analysis. Everyone knows and loves maps, but what’s GIS, you say: Geospatial Information Systems (GIS) is an area of cartography and information technology concerned with the storage, manipulation, analysis, and presentation of geographic and spatial data. You are probably most familiar with GIS services that produce dynamic, two-dimensional tile maps which have been prominent on the web since the days of . MapQuest In this article, I’ll examine how to implement GIS techniques with JavaScript and HTML, focusing on lightweight tools for specific tasks. Many of the tools I’ll cover are based on services such as Mapbox, CloudMade, and MapZen, but these are all modular libraries that can be added as packages to Node.js or used for analysis in a web browser. : The CodePen examples embedded in this post are best viewed on CodePen directly. Note Geometry & 3D Distance and Measurement It is especially useful to have small, focused libraries that perform distance measurement, and conversion operations, such as finding the area of a or converting miles to kilometers. The following libraries work with formatted objects representing geographic space. geo-fence GeoJSON provides distance (and estimated time) calculations between two latitude-latitude coordinates. A handy feature of Geolib is , which sorts a list or array by distance. The library also supports elevation. Geolib order by distance , which is described in the next section, also provides a distance function to calculate the between two points. Additionally, Turf.js calculates area, distance along a path, and the midpoint between points. Turf.js great-circle distance is a library for geometry, vector, and matrix math in JavaScript. This library is helpful when basic measurement of lines and planes is not enough. Sylvester 3D While the above libraries work well for 2D projections of geography, three-dimensional GIS is an exciting and expansive field—which is natural because we live 3D space. Fortunately, WebGL and the HTML5 canvas have also opened up for web developers. new 3D techniques is a JavaScript library for geometric and mesh objects. The to Three.js provides a simple way to render GeoJSON objects on 3D planes and spheres. Three.js Three GeoJSON extension allows the map designer to represent buildings as 3D objects on a 2D map. The project uses OpenLayers and Leaflet. This can be used to great effect, for example Tom Holderness . The OSM Buildings project used OSM Buildings to map London Here’s an example of how to display GeoJSON Features on a 3D object: CSS JSResult Skip Results Iframe
EDIT ON
// Render GeoJSON features on a spherical object.
// Create Three.js scene, camera, & light
var WIDTH = window.innerWidth - 30,
 HEIGHT = window.innerHeight - 30;
 
var angle = 75,
 aspect = WIDTH / HEIGHT,
 near = 0.5,
 far = 1000;

var scene = new THREE.Scene();
var camera = new THREE.PerspectiveCamera(angle, aspect, near, far);

// Renderer the canvas
var renderer = new THREE.WebGLRenderer();
renderer.setSize( WIDTH, HEIGHT);
renderer.setClearColor( 0x555555, 1);
document.body.appendChild(renderer.domElement);

// create a point light (goes in all directions)
scene.add(new THREE.AmbientLight(0x71ABEF));
var pointLight = new THREE.PointLight(0x666666);

// set its position
pointLight.position.x = 60;
pointLight.position.y = 50;
pointLight.position.z = 230;
scene.add(pointLight);

// Create a sphere to make visualization easier.
var geometry = new THREE.SphereGeometry(10,32,32);
var material = new THREE.MeshPhongMaterial({
 color: 0xDDDDDD,
 wireframe: false,
 transparent: true
});
 
var sphere = new THREE.Mesh(geometry, material);
scene.add(sphere);
sphere.castShadow = true;
sphere.receiveShadow = true;

//Draw the GeoJSON at THREE.ParticleSystemMaterial
var countries = $.getJSON("https://s3-us-west-2.amazonaws.com/s.cdpn.io/230399/countries_states.geojson", function (data) { 
 drawThreeGeo(data, 10, 'sphere', {
 color: 0x8B572A,
 skinning: true
 }); 
});

var rivers = $.getJSON("https://s3-us-west-2.amazonaws.com/s.cdpn.io/230399/rivers.geojson", function (data) { 
 drawThreeGeo(data, 10, 'sphere', {
 color: '#4A90E2'
 }); 
});

//Set the camera position
camera.position.z = 20; 

//Enable controls
controls = new THREE.TrackballControls(camera);

// Slow down zooming
controls.zoomSpeed = 0.1;

//Render the image
function render() {
 controls.update();
 requestAnimationFrame(render); 
 renderer.render(scene, camera);
 }

render(); You can also check out Byron Houwen’s , which shows how to create a terrain map of earth with Three.js article on WebGL and JavaScript Geo Features & Points Much of the work in GIS involves dealing with points, shapes, symbols, and other features. The most basic task is to add a shape or point features to a map. The well-established Leaflet library and newcomer Turf.js make this much easier and allow users to work with feature collections. is simply the best option for working with the display of points, symbols, and all types of features on web and mobile devices. The library supports , , , , , and a wide variety of layers. It performs quickly and handles a variety of formats. The library also has . Leaflet rectangles circles polygons points custom markers a rich ecosystem of third-party plug-ins is a library from for geospatial analysis. One of the great things about Turf.js is that you can create a collection of features and then spatially analyze, modify (geoprocess), and simplify them, before using Leaflet to present the data. Like Geolib, Turf.js will calculate the path length, feature center, points inside a feature. Turf.js Mapbox creates and other symbology by simply defining a GeoJSON object and data attribute. Simple Map D3 choropleths The following is an example of using Turf.js to calculate the population density of all counties in the state of California and then displaying the results as a Leaflet choropleth map. // Public auth for initializing the map
var mapMain = 'stevepepple.lkojhhoh';
L.mapbox.accessToken = 'pk.eyJ1Ijoic3RldmVwZXBwbGUiLCJhIjoiTmd4T0wyNCJ9.1-jWg2J5XmFfnBAhyrORmw';

// Quantile or Jenks classification
var type = $("#type").val();
var breaks;

// Color scale using chroma.js
var scale = chroma.scale('YlOrBr');

// Create the base map using Mapbox
map = L.mapbox.map('map', mapMain, {
 attributionControl: false,
 maxZoom: 12,
 minZoom: 5
}).setView([34.0261899, -118.2455643], 8);

// Calculate population density for each county
_.each(counties.features, function(feature) {
 // Population from 2010 Census
 var pop = feature.properties.POP;
 // Calcualate desnity as popluation / square meters 
 var area = turf.area(feature.geometry);
 var sq_miles = area * 0.000000386102158542;
 feature.properties.pop_density = (pop / sq_miles);
});

updateMap();

// Show the Choropleth of Population Density
function updateMap() {
 // Make a Turf collection for analysis
 collection = turf.featurecollection(counties.features);

 // Basic UI for select Jenks or Quantile classification
 if (type == "jenks") {
 breaks = turf.jenks(collection, "pop_density", 8);
 } else {
 breaks = turf.quantile(collection, "pop_density", [25, 50, 75, 99]);
 }
 // Get the color when adding to the map
 var layer = L.geoJson(counties, {
 style: getStyle
 })
 layer.addTo(map);
 // Fit to map to counties and set the legend
 map.fitBounds(layer.getBounds());
 updateLegend();

 function getStyle(feature) {
 var pop = feature.properties.POP;
 var pop_density = feature.properties.pop_density;
 return {
 fillColor: getColor(pop_density),
 fillOpacity: 0.7,
 weight: 1,
 opacity: 0.2,
 color: 'black'
 }
 }

 function updateLegend() {
 $(".breaks").html();
 for (var i = 0; i < breaks.length; i++) {
 var density = Math.round(breaks[i] * 100) / 100;
 var background = scale(i / (breaks.length));
 $(".breaks").append("<div class='icon' style='background: " + background + "'></div> " + density + " pop / mi2");
 }
 }
}

/* Get color depending on population density value */
function getColor(d) {
 // Select a color scale from Color Brewer 
 var color = scale(0);
 // Place the feature based upon breaks
 for (var i = breaks.length - 1; i >= 0; i--) {
 if (d < breaks[i]) {
 // Automatic way to select the color by class
 var percentage = (i / (breaks.length));
 color = scale(percentage);
 }
 }
 return color;
} A key concept in Turf.js is , such as polygons. These feature are typically GeoJSON features that you want to analyze, manipulate, or display on a map. You start with a with an array of county features. Then, create a collection from this object: a collection of geographic features GeoJSON object collection = turf.featurecollection(counties.features); With this collection you can perform many useful operations. You can transform one or more collections with joins, intersections, interpolation, and exclusion. You can calculate descriptive statistics, classifications, and sample distributions. In the case of population density, you can calculate the natural breaks ( ) or quantile classifications for population density: Jenks optimization breaks = turf.jenks(collection, "pop_density", 8); The population density (population divided by area) value was calculated and stored as a property of each county, but the operation works for any feature property. Working with Points Points are a special type of geographic feature representing a latitude-longitude coordinate (and associated data). These features are frequently used in web applications, e.g. to display a set of nearby businesses on a map. Turf.js provides a number of different operations for points, including finding the centroid point in a feature and creating a rectangle or polygon that encompasses all points. You can also calculate statistics from points, such as the average based on a data value for each point. There are also extensions for Leaflet.js that help when dealing with a large number of points: is great for visualizing the results from Turf, or a collection of points that is large. The library itself handles hundreds of points, but there are plugins like Marker Cluster and Mask Canvas for handling hundreds of thousands of points. Marker Cluster for Leaflet creates a dynamic heat map from point data. It even works for datasets with thousands of points. Heat for Leaflet Geocoding & Routing Routing, geocoding, and reverse geocoding locations requires an online service, such as Google or Nokia Here, but recent libraries have made the implementation easier. There are also suitable open source alternatives. The provides a simple method of getting a device’s GPS location (with user permission): HTML5 Geolocation API navigator.geolocation.getCurrentPosition(function(result){
 // do something with result.coords
); Location-aware web applications can use Turf.js spatial analysis methods for advanced techniques such as geofencing a location inside or outside of a map feature. For instance, you can take the result from the above example and use the method to see if that coordinate is within the boundaries of a given neighborhood. turf.inside is a Leaflet plugin for geocoding that allows the developer to choose between the ArcGIS, Google, and OpenStreetMaps geocoder. Once the control is added to the base map, it will automatically use the selected geocoding service to show the best search result on the map. The library is designed to be extensible to other third-party services. GeoSeach is a geocoding library that uses Google’s Geocode API for geocoding and reverse geocoding. It additionally supports the system for URL encoding of latitude-longitude coordinates. Geo for Node.js Geohash As with geocoding, there are myriad routing and direction services, but they will cost you. A reliable, open source alternative is the service by MapZen. It provides a free service for routing car, bicycle, and pedestrian directions. cleverly uses the OSRM Routing tool for creating routes in their transportation planning tool. Open Source Routing Machine (OSRM) Transit Mix Spatial and Network Analysis I’ve mentioned a few spatial analysis methods you can implement with Turf.js and other libraries, but I’ve only covered a small part of a vast world. I’ve created an example application that illustrates several of the techniques I’ve introduced. /* Calculate the center of all points */
function findCenter() {
 var centroidPt = turf.centroid(points);
 var marker = L.geoJson(centroidPt)
 markers.push(marker)
 marker.addTo(map);
}

/* Find the rectangular boundary of all points */
function findBounds() {
 bbox = turf.extent(points);
 bboxPolygon = turf.bboxPolygon(bbox);

 var bounds = L.geoJson(bboxPolygon);
 map.fitBounds(bounds.getBounds());
}

// Show a pseudo-random sample of points in the box
function randomSample() {
 var sample = L.geoJson(turf.sample(points, 100), {
 style: circle_options
 })
 sample.addTo(map);
 markers.push(sample);
}

/* Find the Most Central POI by Neighborhood */
function findCentralPOIs() {
 hoods = turf.featurecollection(neighborhoods.features);
 display = L.geoJson(hoods, {
 style: hood_options
 }).addTo(map);

 _.each(hoods.features, function(feature) {
 try {
 var center = turf.centroid(feature);
 var nearest = turf.nearest(center, points);
 var marker = L.geoJson(center)
 markers.push(marker)
 marker.addTo(map);
 } catch (e) {
 console.log(e)
 }
 });
}

/* Find the Most Central POI by Neighborhood */
function hoodByPOI() {
 hoods = turf.featurecollection(neighborhoods.features);
 display = L.geoJson(hoods, {
 style: hood_options
 }).addTo(map);

 _.each(hoods.features, function(feature) {
 try {
 console.log(feature)
 var collection = turf.featurecollection(feature);
 //var aggregated = turf.sum( hoods, points, 'population', 'sum');

 var counted = turf.count(collection, points, 'pt_count');
 console.log(counted)
 } catch (e) {
 console.log(e)
 }
 });
}

/* Triangular Irregular Network */
function makeTIN() {
 // THis collection was pre-made using the spatial join (turf.tag) feature
 var collection = westlake;

 var tin = turf.tin(collection);
 //var markers = L.geoJson(collection).addTo(map);
 var display = L.geoJson(tin, tin_options);
 display.addTo(map);
 markers.push(display);
 map.fitBounds(display.getBounds());

 _.each(collection.features, function(x) {
 // Convert lat/long to Leaflet coord 
 var coord = L.latLng(x.geometry.coordinates[1], x.geometry.coordinates[0]);
 var radius = 30;
 var circle = L.circle(coord, radius, circle_options).addTo(map);
 markers.push(circle);
 });
}

// Heat map of all points using Leaflet Heatmap
function makeHeatMap() {
 coords = []; //define an array to store coordinates
 heat_options = {
 radius: 14,
 gradient: {
 0.4: '#80cdc1',
 0.65: '#b8e186',
 1.0: '#d01c8b'
 }
 }

 _.each(points.features, function(feature) {
 coords.push([feature.geometry.coordinates[1], feature.geometry.coordinates[0]]);
 });

 var scale = chroma.scale('PuBuGn');

 try {
 var heat = L.heatLayer(coords, heat_options)
 markers.push(heat);
 heat.addTo(map);
 map.setZoom(14);
 } catch (e) {
 console.log(e)
 }
}

// Show or Hide LA Neighborhoods
function showNeighborhoods(hide) {
 if (hide == true) {
 map.removeLayer(display_hoods)
 } else {
 display_hoods = L.geoJson(hoods, {
 style: hood_options
 });
 display_hoods.addTo(map);
 }
}

// Util function to clear all features/markers
function clearMap() {
 for (i = 0; i < markers.length; i++) {
 map.removeLayer(markers[i])
 }
}

// UI for calling the different functions 
function bindActions() {
 doAnalysis(showNeighborhoods);
 
 $("#show_hoods").change(function() {
 var checked = $(this).prop("checked");
 if (checked == true) {
 showNeighborhoods();
 } else {
 showNeighborhoods(true);
 }
 });
}

function doAnalysis(which, arg) {
 clearMap();
 which.call(this, arg);
}

/* Map Setup, which is less interesting */
var mapMain = 'osaez.kp2ddba3';
L.mapbox.accessToken = 'pk.eyJ1Ijoib3NhZXoiLCJhIjoiOExKN0RWQSJ9.Hgewe_0r7gXoLCJHuupRfg';

map = L.mapbox.map('map', mapMain, {
 attributionControl: false,
 maxZoom: 14,
 minZoom: 5
}).setView([34.0261899, -118.2455643], 10);

var markers = [];
var layers = [];
var hoods, points, display_hoods;

var circle_options = {
 color: '#053275',
 opacity: 0,
 weight: .5,
 fillColor: '#3490E7 ',
 fillOpacity: .5
};

var hood_options = {
 color: "#9013FE",
 weight: .4,
 opacity: 0.65,
 fillColor: "#9013FE",
 fillOpacity: .01
};

var tin_options = {
 color: "#417505",
 weight: .4,
 opacity: 0.65,
 fillColor: "#417505 ",
 fillOpacity: .1
};

//Convert Shapefile to GeoJSON using Shapefile.js
shp("https://s3-us-west-2.amazonaws.com/s.cdpn.io/230399/la-poi-only.zip").then(function(geojson) {
 json = geojson;
 points = turf.featurecollection(json.features);
 hoods = turf.featurecollection(neighborhoods.features);
 prepAnalysis();
});

function prepAnalysis() {
 // Show a box around all possible points of interest
 hull = turf.convex(points);
 layer = L.geoJson(hull);
 bindActions();
} Conclusion In this article, I hope to have provided a comprehensive overview of the tools which are available to perform geospatial analysis and geoprocessing with JavaScript. Are you using these libraries in your projects already? Did I miss any out? Let me know in the comments. If you want to go even further with geospatial analysis and geoprocessing with JavaScript, here are a few more resources and utilities: and — includes a number of examples of using D3 with maps and spatial analysis. One of the more interesting examples is creating a directed graph of the New York Metro, which is done by analyzing the Google Transit specification for MTA with NetworkX. NetworkX D3.js Mike Dewars’ book on D3.js — Turf uses Vladimir Agafonkin’s Simply.js to perform shape simplification. That library can also be installed as an independent Node.js package for online or offline processing of files. Simply.js — Ben Southgate’s d3.geo.exploder allows you to transition geographic features (geoJSON) to another shape, like a grid or a scatter plot. d3 Geo Exploder — Use this library to convert a shapefile (and data files) to GeoJSON Shp — Use this library to convert KML & GPX to GeoJSON ToGeoJSON – Use this library to convert geodata into 3D models that can be rendered or 3D printed. Shp2stl and — use these libraries to convert between coordinate systems. MetaCRS Proj4js Also published on: https://www.sitepoint.com/javascript-geospatial-advanced-maps/

How to Implement GIS Techniques with JavaScript and HTML

In a previous post of this series [1], we introduced how to use the Python-based graph analysis library NetworkX [2] and [3] to analyze the character relationships in “Game of Thrones”. Nebula Graph In this post, we are going to explore how to use the Java-based graph analysis library JGraphT [4] and the diagramming library mxGraph [5] to visualize the changes of correlation between the S&P 100 Index stocks [6] over time. Dataset Processing The main analysis method used in this post refers to [7] and [8]. There are two datasets: the vertex set and the edge set. Stock Data (Vertex Set) Select the following S&P 100 Index stocks, and model each stock as a vertex. The properties of each vertex are the stock code and the industry of the listed company. Table 1: The vertex set sample Stock Relationship (Edge/Relationship Set) Each edge has only one property, i.e. the weight. The weight of an edge indicates the daily return rate similarity of the listed companies represented by the vertices (stocks) on both ends of the edge. The similarity algorithm refers to [7] and [8]: analyze the time-series correlation of the individual stocks’ daily return rate over a period of time (from 2014-01-01 to 2020-01-01), and define the distance between the individual stocks (i.e. the edge weight) as follows. Through such processing, we get the range of the distance as [0,2]. That means the more distant the two stocks, the lower the correlation between their return rates. Table 2: The edge set sample Such a vertex set and an edge set form a graph network, which can be stored in the Nebula Graph database. JGraphT JGraphT is an open-source Java class library that provides not only a variety of efficient and common graph data structures but also many useful algorithms for solving the most common graph problems. The features of JGraphT are as follows: Supports directed edges, undirected edges, weighted edges, non-weighted edges, etc. Supports simple graphs, multigraphs, and pseudographs. Provides dedicated iterators (DFS, BFS, etc.) for graph traversals. Provides a large number of commonly used graph algorithms, such as path lookup, isomorphism detection, coloring, common ancestors, wandering, connectivity, matching, cycle detection, partitioning, cutting, flow, and centrality. Provides easy import from/export to GraphViz. The exported GraphViz file can be applied by the visualization tool Gephi for analysis and demonstration. Supports convenient graph network generating while used with tools such as JGraphX，mxGraph, and Guava Graphs Generators. Next, let’s try it out. 1. Create a directed graph in JGraphT. org.jgrapht.*; org.jgrapht.graph.*; org.jgrapht.nio.*; org.jgrapht.nio.dot.*; org.jgrapht.traverse.*; java.io.*; java.net.*; java.util.*;

Graph<URI, DefaultEdge> g = DefaultDirectedGraph<>(DefaultEdge.class);

URI google = URI( );
URI wikipedia = URI( );
URI jgrapht = URI( ); import import import import import import import import new new "http://www.google.com" new "http://www.wikipedia.org" new "http://www.jgrapht.org" 2. Add vertices. g.add ;
g.add ;
g.add ; Vertex( ) google Vertex( ) wikipedia Vertex( ) jgrapht 3. Add edges. g.add ;
g.add ;
g.add ;
g.add ; // Add edges to create a linked structure Edge( , ) jgrapht wikipedia Edge( , ) google jgrapht Edge( , ) google wikipedia Edge( , ) wikipedia google The Nebula Graph database JGraphT usually uses local files as data sources. That’s fine when you’re doing static network research, but if the graph network is constantly changing, like a graph network of the stock data, which changes every day, it’s a little bit of a hassle to generate a new static file, then load it and then analyze it every time. Ideally, the entire change process can be written to a database persistently, and subgraphs or the complete graph can be loaded directly from the database in real-time for analysis. In this post, we use Nebula Graph as the graph database for storing the graph data. Nebula Graph’s Java client nebula-java [11] provides two ways of accessing Nebula Graph. One is interacting with the query engine layer [13] through the graph query language nGQL [12], which is usually suitable for accessing subgraphs and supports complex semantics; the other is to directly interact with the underlying storage layer (the storaged process) [14] through the APIs, which is used to obtain the complete set of vertices and edges. In addition to accessing Nebula Graph itself, nebula-java provides examples of interacting with Neo4j [15], JanusGraph [16], Spark [17], and others. In this post, we use the APIs to access the storage layer (the storaged process) directly to get all the vertices and edges. The following two interfaces can be used to read all the vertex and edge data. ; ; // space is the name of the graph space to be scanned, and returnCols is the vertex/edge and its properties to be read. // Format of returnCols parameter: {tag1Name: prop1, prop2, tag2Name: prop3, prop4, prop5} Iterator<ScanVertexResponse> scanVertex (
 Stringspace, Map<String, List<String>>returnCols) Iterator<ScanEdgeResponse> scanEdge (
 Stringspace, Map<String, List<String>>returnCols) 1. Initialize a client and a ScanVertexProcessor. ScanVertexProcessor is used to decode the read vertex data: MetaClientImpl metaClientImpl = MetaClientImpl(metaHost, metaPort);
metaClientImpl.connect();
StorageClient storageClient = StorageClientImpl(metaClientImpl);
Processor processor = ScanVertexProcessor(metaClientImpl); new new new 2. Call the scanVertex interface, which returns an iterator for the scanVertexResponse object: Iterator<ScanVertexResponse> iterator =
 storageClient.scanVertex(spaceName, returnCols); 3. Keep reading the data in the scanVertexResponse object that the iterator points to until all of the data is read. The read vertex data is saved and later added to the graph structure of JGraphT. (iterator.hasNext()) {
 ScanVertexResponse response = iterator.next(); (response == ) {
 log.error( ); ;
 }
 
 Result result = processor.process(spaceName, response);
 results.addAll(result.getRows(TAGNAME));
} while if null "Error occurs while scan vertex" break Reading edge data is similar to the above process. Analyze the Graph in JGraphT 1. Create an undirected and weighted graph in JGraphT : Graph<String, MyEdge> graph = GraphTypeBuilder
 .undirected()
 .weighted( )
 .allowingMultipleEdges( )
 .allowingSelfLoops( )
 .vertexSupplier(SupplierUtil.createStringSupplier())
 .edgeSupplier(SupplierUtil.createSupplier(MyEdge.class))
 .buildGraph(); true true false 2. Add the vertex and edge data read in the last step from the Nebula Graph space to the graph: (VertexDomain vertex : vertexDomainList){
 graph.addVertex(vertex.getVid().toString());
 stockIdToName.put(vertex.getVid().toString(), vertex);
} (EdgeDomain edgeDomain : edgeDomainList){
 graph.addEdge(edgeDomain.getSrcid().toString(), edgeDomain.getDstid().toString());
 MyEdge newEdge = graph.getEdge(edgeDomain.getSrcid().toString(), edgeDomain.getDstid().toString());
 graph.setEdgeWeight(newEdge, edgeDomain.getWeight());
} for for 3. Like the analysis algorithms mentioned in [7] and [8], use Prim’s minimum-spanning tree algorithm for the preceding graph and call the encapsulated drawGraph interface to draw the graph. Prim’s algorithm is an algorithm in graph theory that searches for a minimum spanning tree in a weighted connected graph. In other words, the tree formed by the edge subset searched by this algorithm not only includes all vertices in the connected graph but also has the minimum sum of weights of all edges. SpanningTreeAlgorithm.SpanningTree pMST = PrimMinimumSpanningTree(graph).getSpanningTree();

Legend.drawGraph(pMST.getEdges(), filename, stockIdToName); new 4. The drawGraph method encapsulates parameter settings such as the layout of the drawing. This method renders stocks in the same sector in the same color, grouping close stocks together. {
 
... { mxGraph graph = mxGraph();
 Object parent = graph.getDefaultParent(); graph.getModel().beginUpdate();
 mxStylesheet myStylesheet = graph.getStylesheet();
 graph.setStylesheet(setMsStylesheet(myStylesheet));

 Map<String, Object> idMap = HashMap<>();
 Map<String, String> industryColor = HashMap<>(); colorIndex = ; (MyEdge edge : edges) {
 Object src, dst; (!idMap.containsKey(edge.getSrc())) {
 VertexDomain srcNode = idVertexMap.get(edge.getSrc());
 String nodeColor; (industryColor.containsKey(srcNode.getIndustry())){
 nodeColor = industryColor.get(srcNode.getIndustry());
 } {
 nodeColor = COLOR_LIST[colorIndex++];
 industryColor.put(srcNode.getIndustry(), nodeColor);
 }
 src = graph.insertVertex(parent, , srcNode.getName(), , , , , + nodeColor);
 idMap.put(edge.getSrc(), src);
 } {
 src = idMap.get(edge.getSrc());
 } (!idMap.containsKey(edge.getDst())) {
 VertexDomain dstNode = idVertexMap.get(edge.getDst());

 String nodeColor; (industryColor.containsKey(dstNode.getIndustry())){
 nodeColor = industryColor.get(dstNode.getIndustry());
 } {
 nodeColor = COLOR_LIST[colorIndex++];
 industryColor.put(dstNode.getIndustry(), nodeColor);
 }

 dst = graph.insertVertex(parent, , dstNode.getName(), , , , , + nodeColor);
 idMap.put(edge.getDst(), dst);
 } {
 dst = idMap.get(edge.getDst());
 }
 graph.insertEdge(parent, , , src, dst);
 }


 log.info( + idMap.size());
 log.info( + industryColor.size());

 mxFastOrganicLayout layout = mxFastOrganicLayout(graph);
 layout.setMaxIterations( ); layout.execute(parent);

 graph.getModel().endUpdate(); BufferedImage image = createBufferedImage(graph, , , Color.WHITE, , ); File file = File(filename);
 ImageIO.write(image, , file);

 }
 
 ...

} public class Legend IOException public static void drawGraph (Set<MyEdge> edges, String filename, Map<String, VertexDomain> idVertexMap) throws // Creates graph with model new // set style new new int 0 for if if else null 0 0 105 50 "fillColor=" else if if else null 0 0 105 50 "fillColor=" else null "" "vertice " "colorsize " new 2000 //layout.setMinDistanceLimit(10D); // Creates an image than can be saved using ImageIO null 1 true null // For the sake of this example we display the image in a window // Save as JPEG new "JPEG" 5. Visualize the data. The color of each vertex in Figure 1 represents its industry. We can see that the stocks with high business similarity have been clustered together, but some stocks with no obvious correlation have also been clustered together, the reason for which needs to be studied separately. Figure 1: Clustering based on the stock data from 2014-01-01 to 2020-01-01 6. Some other dynamic exploration based on different time windows. The preceding conclusion is mainly based on the stock aggregation from 2014-01-01 to 2020-01-01. We also made other attempts: Use a sliding window of 2 years and the same analysis method to observe if the clustered groups would change over time. Figure 2: Clustering based on the stock data from 2014-01-01 to 2016-01-01 Figure 3: Clustering based on the stock data from 2015-01-01 to 2017-01-01 Figure 4: Clustering based on the stock data from 2016-01-01 to 2018-01-01 Figure 5: Clustering based on the stock data from 2017-01-01 to 2019-01-01 Figure 6: Clustering based on the stock data from 2018-01-01 to 2020-01-01 According to a rough analysis, with the change of time window, the clustering of stocks within most industries maintains relatively good, which means that with the change of time, all kinds of stocks within the same industry maintain relatively high correlation. Disclaimer This post should not be taken as investment advice. Due to the situation of trade suspension, circuit breakers, trading limits, transfers, mergers and acquisitions, changes of the main business, etc., the data processing in this post may be incorrect. We have not checked all the data piece by piece. Limited by time, this post only selects the data of 100 stock samples in the past six years, and only adopts the method of minimum expansion tree to do the clustering and classification. In the future, maybe we can use larger data sets (such as U.S. stocks, derivatives, and digital currencies) to try more methods in machine learning. For the code used in this post, please see [18]. References [1] Analyzing Relationships in Game of Thrones With NetworkX, Gephi, and Nebula Graph (Part One) https://nebula-graph.io/posts/game-of-thrones-relationship-networkx-gephi-nebula-graph/ [2] Analyzing Relationships in Game of Thrones With NetworkX, Gephi, and Nebula Graph (Part Two) https://nebula-graph.io/posts/game-of-thrones-relationship-networkx-gephi-nebula-graph-part-two/ [3] NetworkX: a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. https://networkx.github.io/ [4] Nebula Graph: A powerfully distributed, scalable, lightning-fast graph database written in C++. https://nebula-graph.io/ [5] JGraphT: a Java library of graph theory data structures and algorithms. https://jgrapht.org/ [6] mxGraph: JavaScript diagramming library that enables interactive graph and charting applications. https://jgraph.github.io/mxgraph/ [7] Bonanno, Giovanni & Lillo, Fabrizio & Mantegna, Rosario. (2000). High-frequency Cross-correlation in a Set of Stocks. arXiv.org, Quantitative Finance Papers. 1. 10.1080/713665554. [8] Mantegna, R.N. Hierarchical structure in financial markets. Eur. Phys. J. B 11, 193–197 (1999). [9] https://graphviz.org/ [10] https://gephi.org/ [11] https://github.com/vesoft-inc/nebula-java [12] Nebula Graph Query Language (nGQL). https://docs.nebula-graph.io/manual-EN/1.overview/1.concepts/2.nGQL-overview/ [13] Nebula Graph Query Engine. https://github.com/vesoft-inc/nebula-graph [14] Nebula-storage: A distributed consistent graph storage. https://github.com/vesoft-inc/nebula-storage [15] Neo4j. www.neo4j.com [16] JanusGraph. janusgraph.org [17] Apache Spark. . spark.apache.org [18] https://github.com/Judy1992/nebula_scan Previously published at https://nebula-graph.io/posts/stock-interrelation-analysis-nebula-graph-machine-learning/

How to Explore the S&P 100 Index Stocks Using Graph Machine Learning

Server-side rendering (SSR) is technique when content for a web page is rendered on the server using JavaScript. SSR speeds initial loading up that, in turn, helps increase Google PageSpeed Performance score for SPA (React.js, Vue.js, Angular, etc.). Usual approach is to use web server such as and render on the server in the fly. We all know that is quite fast, but we want to boost our web app to maximum available speed. Node.js Express.js Node.js Does SSR require Node.js? Commonly, React.js Apps have static numbers of routes. So, we can easily make rendered pages at the same stage when JavaScript bundles are generating. So, we can use these static HTML files with any web server that lets to implement routing logic. That basically means by getting a route, e.g: the web server returns according an HTML file that is created by using test.com/test ReactDOMServer.renderToString() React App Setup Let's first start with preparing front-end side as an example will be using . React.js We need to create a simple React.js website with three routes. At first, we should create a file with Routes for using it in React app and web server. ROUTES = { : , : , : ,
}; .exports = ROUTES; const HOME_PAGE '/' ABOUT '/about' CONTACT '/contact' // Keep it as CommonJS (Node.js) export module Normally, React.js app optimisation starts with code splitting. In our case is good to split code by routes. Good choice for it is using . This library has ready to go solution for SSR that is located in the npm package. The first package allow to use dynamic import inside React, therefore Webpack can split bundle by these imports . @loadable/component @loadable/server HomePage = loadable( ( ), { : const => () import './pages/home/HomePage' fallback ,
}); < /> Loading In addition, we should use instead of for SSR side. To achieve this we can have two different entry points: App.jsx and AppSsr.jsx, the last one includes: StaticRouter BrowserRouter { StaticRouter } ; Routes ; { ( <Routes /> );
} import from 'react-router' import from './Routes' ( ) function App { route } return < = > StaticRouter location {route} </ > StaticRouter Next task for us is creating a function that creates an HTML file by route. Using code looks like that: @loadable/server { ChunkExtractor } = ( ); { nodeExtractor = ChunkExtractor({ : nodeStats }); { : App } = nodeExtractor.requireEntrypoint(); webExtractor = ChunkExtractor({ : webStats }); jsx = webExtractor.collectChunks(React.createElement(App, { route })); innerHtml = renderToString(jsx); css = webExtractor.getCssString(); data = {
 innerHtml, : webExtractor.getLinkTags(), : webExtractor.getStyleTags(), : webExtractor.getScriptTags(),
 css,
 }; templateFile = path.resolve(__dirname, );

 ejs.renderFile(templateFile, data, {}, (err, html) => { (err) { .error(err); (err);
 } { htmlMini = minify(html, { : , : ,
 });
 fs.writeFile( , htmlMini, , () => { .log( );
 });
 }
 });
} const require '@loadable/server' async ( ) function createServerHtmlByRoute route, fileName const new statsFile const default const new statsFile const const const await const linkTags styleTags scriptTags const './index-ssr.ejs' if console throw new Error else const minifyCSS true minifyJS true ` / .html` ${distPath} ${fileName} 'utf8' console `>>>>>>>>>>>>>>>> for Route: ----> .html --> Ok` ${route} ${fileName} So, now we can go throw our routes and create all HTML files that we need: {
 process.env.NODE_ENV = ; .entries(ROUTES).forEach( ([key, value]) => {
 routes.push([
 value.substr( ),
 key.toLowerCase(),
 ]); { createServerHtmlByRoute(value, key.toLowerCase());
 } (e) { .error(e);
 process.exit( );
 }
 });
} async ( ) function generateSsr 'production' Object async 1 try await catch console 1 As you noticed in the function there is an HTML template which we are using for putting into it generated HTML and CSS: createServerHtmlByRoute <!DOCTYPE html> < = > html lang "en" < > head < = > style id "css-server-side" < %> %- css </ > style < %> %- linkTags </ > head < > body < = > div id "app" < %> %- innerHtml </ > div < %> %- scriptTags < %> %- styleTags </ > body </ > html It looks like this approach is not perfect because in this case, each HTML file contains some CSS duplicates, such as CSS libraries or common CSS. But it is the simplest solution for speed initial loading up. Another one is an feature - when a Web Server pushing CSS files with HTML together. HTTP/2 Server Push Finally, after running the build script we should get HTML files for all routes and default - index.html: Full example is located in the GitHub repository Thus, we got everything that we need from JavaScript/React.js side. will cover Rust Web server implementation. The next article You can check how this approach works in production by getting Google PageSpeed Insights Performance score for website. PageSpeed Green Happy coding! * Website vector created by slidesgo - www.freepik.com

How To Improve React App Performance with SSR and Rust 
[Part I: SSR]

A big thanks to engineering specifically and for letting me share this code and all of their help and support while building the user tutorial feature on our . Dexter Daniel Ilkovich David Hu site While React has ways to break the hatch and directly manipulate the DOM there are very few reasons to do this. We shouldn’t directly manipulate the DOM unless we have a really good reason to. When we need to we should use the property. Only as a last resort should we manipulate the DOM directly as well as change state during a render. ref The Problem The grid snaps at 1024px from a fixed to a fluid grid. We wanted our tutorial tips to be 20px away from their parent element and there wasn’t a way to do this with just css. If the tip was positioned correctly in the fixed grid it would be off when the grid snapped to a fluid view. The tutorial metadata is applied directly in inline styles of the component which has the highest css specificity. This meant that media queries couldn’t solve this problem because media queries would be overridden by css with higher specificity. The Solution The solution needed to be a single set of metadata and a component that knew where it was so it could change its positioning on the fly. Here’s a video of the final component styles changing. and the component moving with the viewport resize. Element.getClientRects() First things first, we need to know where the parent element is on the page before we can do anything with it. The does just that. If you query an element on the DOM and call it’ll return an object of values with the position, height and width of that element in relation to the viewport of the browser. Give it a try on your end. .getClientRects() method .getClientRects() querying an element on NYTimes.com Using a Stateful Component to store positioning We need the component to know where it is at all times. Thinking about that requirement we need a component that can hold its own state, not a stateless functional component. This is because the user can shrink or expand their viewport past or less than the 1024px threshold which changes our grid to fluid or fixed position. The component needs to be aware of viewport size so it can hold on to its dynamically generated positioning any time the screen size changes. class Getters and Setters The component has two core functions around dynamic positioning. Setting styles dynamically in relation to where the parent element is on the screen and getting those set styles to render the position of the tip. We’ve named these function methods and . getStyles setStyles In this particular use cases we load in JSON data for each tutorial tip and accordingly for each tip positioning type. This isn’t a requirement for a self positioning component itself. Just information for the tutorial. Examples are instruction text and offset positioning so the tip is 20px away from it’s parent element and centered. tutorialMeta setState Note: Now, it’s time to take this functionality and hook it into React’s lifecycle methods so the component know’s when to update its own positioning. Connecting to React’s Life Cycle Methods Let’s hook up our getters and setters so our component knows when to fire them and update its props and state. Initialization and Destruction: On component load we need to since we currently don’t have any styles to get! Remember, the component is going to call which is going to dynamically set positioning values. Additionally, we don’t want to query the DOM every time we resize the viewport. setStyles .getClientRect() We check if our props or state has changed. 's default is to return true if any state changed per React’s . Since we’re also getting data from our container component as props we also need to check for props updates. There is global dispatch and data for the entire tutorial like and this isn’t a requirement for every use case, just the one that we we’re solving for. shouldComponentUpdate docs Note: nextStep currentStep Next up is fired before a mounted component receives new props ( ). Using rather than blows away state and sets the component to not show. This is also for a very specific and deliberate for our use case, the flickering problem. componentWillRecieveProps docs replaceState setState There was a flickering problem The dreaded flicker! It was ever so subtle, but it made our team twitch. There was a flash on initial load and when transitioning the tutorial tip it would hangout just one render step before where it was supposed to be. That’s where the position came in. If there’s no positioning to give our component just make sure it’s off the page entirely. The Flash Flicker: -9999 Every time we get new props the component sets our display to false removing the component from the DOM entirely during transitions. If you look in , and you’ll see reference to how the component is removed and added with set to false or true. The Hanging Flicker: componentWillRecieveProps setStyles getStyles display The Render This is the function that’s going to get our dynamically generated styles which is called in the styles . is our own custom function that’ll create a string which we can add to a component class styles. We’re not going to dig into this function because it’s out of scope of the post. But, if you’re interested please leave a comment on the bottom of the post and I’ll try and answer your questions. props Note: _.getClassNameFromObject Here’s a diagram of our component lifecycle, getters, setters and render methods. The Entire Component But wait there’s more! We also came up with an interesting solution to avoid adding components all over our application. This is useful if you need to add a series of components to your application like a tutorial. In we query the DOM for a specific step rather than include the component multiple times. The container component renders the component once, then on each step change we look for a different step class to render the tutorial component. setStyles That’s all folks Hopefully this helps anyone how might need this type of dynamic positioning functionality in their React application.

Self Positioning React Components

In the world of web design and development, achieving pixel-perfect alignment of objects on a canvas is crucial for creating visually appealing and polished user interfaces. Object snapping, which allows objects to align to predefined guidelines or other objects, plays a vital role in ensuring precise positioning and spacing. Fabric.js, a powerful and feature-rich JavaScript library for working with HTML5 canvas, provides various tools and functionalities to facilitate object snapping. In this article, we will delve into the concept of object snapping and introduce the SnappyRect class, a custom implementation that extends the functionality of Fabric.js. A. Importance of Object Snapping in Web Design and Development When designing user interfaces or working on graphic-intensive web projects, aligning elements accurately is key to achieving a professional and visually pleasing outcome. Object snapping simplifies this process by automatically aligning objects to specific guidelines or nearby objects, making it easier to maintain consistent spacing and alignments. By incorporating object snapping into your web design workflow, you can save valuable time that would otherwise be spent manually adjusting and aligning objects. Additionally, object snapping helps ensure a seamless and cohesive user experience by eliminating small visual inconsistencies that may arise due to misaligned elements. B. Overview of the SnappyRect Class in Fabric.js Fabric.js offers a wide range of tools and utilities for . Nevertheless, the library doesn't have a built-in object snapping feature. To overcome this restriction, we can use the flexibility of Fabric.js to develop our personalized object snapping system. handling canvas objects The SnappyRect class is an extension of the base fabric.Rect class in Fabric.js. It enhances the functionality of a rectangular object by adding custom guide lines that assist in object snapping. These guides, represented by lines, indicate the , , , , , and positions of the SnappyRect object. top bottom left right center horizontal center vertical In the next sections, we will explore the inner workings of the SnappyRect class and understand how it leverages Fabric.js to create and manipulate these custom guides. We will also learn how to integrate the SnappyRect class into our projects, enabling us to achieve precise object snapping in our canvas-based applications. II. Understanding the SnappyRect Class In this section, we will explore the structure and inner workings of the SnappyRect class. Understanding how the class is implemented will provide insights into how the custom guides are created and managed for object snapping. Complete code: https://github.com/dinesh-rawat-dev/fabricjs-prodeasy-snappy-rect Demo: https://codesandbox.io/s/fabric-js-smart-guides-snappy-rect-z9xd67 A. Overview of the SnappyRect Class Structure The SnappyRect class is created as an extension of the base fabric.Rect class provided by Fabric.js. It inherits all the properties and methods of the base class and adds custom functionality specific to object snapping. const SnappyRect = fabric.util.createClass(fabric.Rect, {
  // Custom properties and methods go here
}); B. The initialize Method and Guide Initialization The initialize method is called when a new instance of the SnappyRect class is created. It overrides the base initialize method to initialize the custom properties of the object. One such property is guides, which is an empty object used to store references to the guide lines. SnappyRect initialize: function(options) {
  options || (options = {});
  this.callSuper("initialize", options);
  this.guides = {};
}, C. The _render Method and Guide Rendering The method is responsible for rendering the SnappyRect object on the canvas. It overrides the base method to ensure that the custom guides are also rendered alongside the rectangular shape. _render _render _render: function(ctx) {
  this.callSuper("_render", ctx);
  this._drawObjectGuides();
}, D. The _drawObjectGuides Method and Guide Positioning The method is where the actual positioning and rendering of the guide lines take place. It calculates the width and height of the object and calls the _drawGuide method for each guide, passing the appropriate position. _drawObjectGuides SnappyRect _drawObjectGuides: function() {
  const w = this.getScaledWidth();
  const h = this.getScaledHeight();
  this._drawGuide("top", this.top);
  this._drawGuide("left", this.left);
  this._drawGuide("centerX", this.left + w / 2);
  this._drawGuide("centerY", this.top + h / 2);
  this._drawGuide("right", this.left + w);
  this._drawGuide("bottom", this.top + h);
  this.setCoords();
}, E. The _drawGuide Method and Guide Creation The method is responsible for creating and positioning individual guide lines based on the given side and position. It uses the fabric.Line class to create a line object, and the lineProps object defines the common properties shared by all guide lines. _drawGuide _drawGuide: function(side, pos) {
  let ln;
  const color = "rgb(178, 207, 255)";
  const lineProps = {
    left: 0,
    top: 0,
    evented: true,
    stroke: color,
    selectable: false,
    opacity: 1
  };

  // Guide line creation based on side and position
  // ...

  if (this.guides[side] instanceof fabric.Line) {
    // Remove the existing line if it already exists
    this.canvas.remove(this.guides[side]);
    delete this.guides[side];
  }

  // Add the new guide line to the canvas
  this.guides[side] = ln;
  this.canvas.add(ln);
}, F. Managing Guide Updates and Interactions To ensure that the guides are updated and interact properly with the SnappyRect object, various methods and event handlers need to be implemented. These may include methods for guide , , and handling object . dragging updating positions transformations By effectively managing these guide interactions, the class enables precise object snapping on the canvas, providing a seamless user experience when aligning and positioning objects. SnappyRect III. Using the SnappyRect Class To make use of the SnappyRect class in your code, follow these instructions: 1. Import the SnappyRect class: import { SnappyRect } from "./fabric-guidelines"; 2. Create an instance of SnappyRect by providing the necessary parameters, such as , , , , and : width height fill top left var snappy = new SnappyRect({
  width: 150,
  height: 150,
  fill: "yellow",
  top: 10,
  left: 10
}); 3. Add the SnappyRect object to the canvas: canvas.add(snappy).renderAll(); With these steps, you have successfully added a SnappyRect object to your canvas. The SnappyRect class will handle the snapping functionality and provide smart guides to align and position the object accurately. In the code, we have already implemented event handlers such as , , and . These event handlers trigger the necessary actions when an object is added or moved on the canvas. The class takes care of drawing the smart guides and performing the snapping behavior. onObjectAdded onObjectMoved onObjectMoving SnappyRect You can customize the appearance and behavior of the SnappyRect object by modifying the parameters passed to the SnappyRect constructor. For example, you can adjust the width, height, fill color, top position, and left position to match your requirements. Feel free to experiment with different parameters and test the snapping behavior of the SnappyRect object on the canvas.

Mastering Object Snapping in Fabric.js: Introducing the SnappyRect Class

Execute a Stored Procedure that gets Data from Multiple Tables in EF Core In EF Core there is not quite yet an elegant way to fetch data from multiple tables by a stored procedure. Lets build one. Why am I writing this. Stored procedure mapping support · Issue #245 · aspnet/EntityFrameworkCore The above issue is the reason why I feel this article is necessary. At the time of writing this article, EF Core’s prescribed way of executing a stored procedure is context.Blogs.FromSql("EXEC Sp_YourSp") but that is only possible if your stored procedure returns data from a particular DB Set (one table or one entity). Lets look at how we can work it around until the above issue is resolved if a stored procedure gets data from multiple tables. The setup We are going to recreate a scenario where we need to do just the above. We are going to write a small API. ‘Todo’ Here is the link containing all the files shown below gist Entities/Models User.cs public class User : EntityBase
{
 public User()
 {
 UserTeams = new HashSet<UserTeam>();
 TaskItems = new HashSet<TaskItem>();
 }

 public string FirstName { get; set; }

 public string LastName { get; set; }

 public string Email { get; set; }

 public string Username { get; set; }

 /// <summary>
 /// Gets or sets the tasks assigned to this user.
 /// </summary>
 public ICollection<TaskItem> TaskItems { get; set; }

 public ICollection<UserTeam> UserTeams { get; set; }
} Team.cs public class Team : EntityBase
{
 public Team()
 {
 UserTeams = new HashSet<UserTeam>();
 }

 /// <summary>
 /// Gets or sets the name of the team.
 /// </summary>
 public string Name { get; set; }

 public ICollection<UserTeam> UserTeams { get; set; }
} UserTeam.cs public class UserTeam : IEntityBase
{
 public int UserId { get; set; }

 public User User { get; set; }

 public int TeamId { get; set; }

 public Team Team { get; set; }
} TaskItem.cs public class TaskItem : EntityBase
{
 public TaskItem()
 {
 Notes = new HashSet<Note>();
 }

 /// <summary>
 /// Gets or sets the name of the task.
 /// </summary>
 public string Name { get; set; }

 /// <summary>
 /// Gets or sets the description of the task.
 /// </summary>
 public string Description { get; set; }

 /// <summary>
 /// Gets or sets the status id of the task.
 /// </summary>
 public int StatusId { get; set; }

 /// <summary>
 /// Gets or sets the status of the task.
 /// </summary>
 public Status Status { get; set; }

 public int UserId { get; set; }

 /// <summary>
 /// Gets or sets the person this task is assigned to.
 /// </summary>
 public User User { get; set; }
} Status.cs public class Status : EntityBase
{
 public Status()
 {
 TaskItems = new HashSet<TaskItem>();
 }

 /// <summary>
 /// Gets or sets the status name.
 /// </summary>
 public string Name { get; set; }

 /// <summary>
 /// Gets or sets the tasks currently in this status.
 /// </summary>
 public ICollection<TaskItem> TaskItems { get; set; }
} Entity.cs /// <summary>
/// Will default the primary key of the entity to be int.
/// </summary>
public class EntityBase : EntityBase<int>
{
}

/// <summary>
/// The base entity.
/// </summary>
/// <typeparam name="TKey">The primary key. </typeparam>
public class EntityBase<TKey> : IEntityBase 
 where TKey: IEquatable<TKey>
{
 /// <summary>
 /// Gets or sets the Id of the entity
 /// </summary>
 public int Id { get; set; }
}

public interface IEntityBase
{
} Now lets say we need to see a progress report where we need the information of teams and users along with the count of all tasks and the tasks which are in state. A stored procedure that accepts optional teamId and userId to get the progress report of all/one team(s) fits the solution to our requirement. todo, in progress and done The stored procedure Lets create a stored procedure as discussed above. Sp_ProgressReport.sql CREATE PROCEDURE [dbo].[Sp_ProgressReport]
@teamId INT NULL,
@userId INT NULL

AS
 SELECT ut.TeamId, ut.UserId, COUNT(t.Id) TotalTasks,
 SUM(CASE WHEN t.StatusId = 1 THEN 1 ELSE 0 END) Todo,
 SUM(CASE WHEN t.StatusId = 2 THEN 1 ELSE 0 END) InProgress,
 SUM(CASE WHEN t.StatusId = 3 THEN 1 ELSE 0 END) Done
 FROM

 [UserTeam] ut
 JOIN [TaskItem] t
 ON ut.UserId = t.UserId

 JOIN [Status] s
 ON t.StatusId = s.Id

 WHERE ut.TeamId = @teamId OR @teamId IS NULL
 AND 
 ut.UserId = @userId OR @userId IS NULL

 GROUP BY ut.TeamId, ut.UserId, s.Id
GO The solution Lets create an entity which is the response of this stored procedure. You can omit creating an entity if you want to as you can directly map the response to an object or dynamic but it helps to have an entity when You have to modify or process the response to apply business logic. There are several related responses of such kind and you want to use some object oriented principles to reuse your entity. ProgressReportEntity.cs public class ProgressReportEntity
{
 public int TeamId { get; set; }

 public int UserId { get; set; }

 public int TotalTasks { get; set; }

 public int Todo { get; set; }

 public int InProgress { get; set; }

 public int Done { get; set; }
} We are going to create a repository for executing the stored procedure. I am not too great a fan of repositories but a lot of developers find it helpful, so I am going to stick to the repository pattern for now. You can create whatever data access abstraction you like. Lets create a few extension methods that will help us irrespective of any pattern we follow. SprocRepositoryExtensions.cs With this, the repository implementation becomes quite simple. SprocRepository.cs public class SprocRepository : ISprocRepository
{
 private readonly TaskPlannerDbContext _dbContext;

 public SprocRepository(TaskPlannerDbContext dbContext)
 {
 _dbContext = dbContext; 
 }

 public DbCommand GetStoredProcedure(
 string name, 
 params (string, object)[] nameValueParams)
 {
 return _dbContext
 .LoadStoredProcedure(name)
 .WithSqlParams(nameValueParams);
 }

 public DbCommand GetStoredProcedure(string name)
 {
 return _dbContext.LoadStoredProcedure(name);
 }
} Once we have got DbCommand from GetStoredProcedure we can call the ExecuteStoredProcedure or ExecuteStoredProcedureAsync from the extension method. I am going to take the liberty to inject repository directly into the controller for now. You can have a business layer abstraction if you want to modify the response if for e.g. you want to calculate the percentage of open, in progress and done tasks. ReportsController.cs [Route("api/[controller]")]
[ApiController]
public class ReportsController : ControllerBase
{
 private readonly ISprocRepository _repository;

 public ReportsController(ISprocRepository repository)
 {
 _repository = repository;
 }

 [HttpGet("Progress")]
 public Task<IList<ProgressReportEntity>> GetProgressReport(
 [FromQuery] int? teamId, 
 [FromQuery] int? userId) 
 {
 (teamId, userId) = (teamId != 0 
 ? teamId 
 : null, 

 userId != 0 
 ? userId 
 : null);

 return _repository
 .GetStoredProcedure("[dbo].[Sp_ProgressReport]")
 .WithSqlParams(
 (nameof(teamId), teamId), 
 (nameof(userId), userId))
 .ExecuteStoredProcedureAsync<ProgressReportEntity>();
 }
} The result Now once we execute this controller by passing 0 in teamId and userId, it will fetch us the progress report of all teams and all users. Here is the result: The Conclusion I hope this really helps you if your requirement or interest aligns with this article. I have made a repository for the same where you can refer this app. Saurabh Pati / TaskPlannerApi Checkout Jeremy Sinclair’s repository for a full blown abstraction of the same snickler/EFCore-FluentStoredProcedure and lastly, do keep a tab on the open issue in ef core’s github repo for a better solution. #245 <a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a>

GETSTYLED

getstyled.in

-- employees

Since n.d.

COMPANY RANKING

GETSTYLED

EVERGREEN INDEX #5033

Representing this company? Click here to claim and customize this page!

GetStyled WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

GETSTYLED

getstyled.in

-- employees

Since n.d.

COMPANY RANKING

GETSTYLED

EVERGREEN INDEX #5033

RELATED COMPANIESRANK

STORIES ABOUT GETSTYLED

Representing this company? Click here to claim and customize this page!

GetStyled WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!