IT did not authorized me to download MongoDB Compass fast enough, so I decided to use the tools available to export a collection. Node.js was authorized, installed and ready for the rescue.

I slightly modified a stackoverflow answer and I was in business really quick.

I put some effort into documenting the parts and pieces of the MongoDB string connection to be aware of the fields/variables that I need to update next time.

Check the repo out...

GitHub - summonidea/mongodb-export-to-json: Using node.js and mongoose package to read a mongo atlas collection and export it to a json file

Using node.js and mongoose package to read a mongo atlas collection and export it to a json file - GitHub - summonidea/mongodb-export-to-json: Using node.js and mongoose package to read a mongo atl...

GitHubsummonidea

Reference

https://stackoverflow.com/questions/5794834/how-to-access-a-preexisting-collection-with-mongoose

The following process has 2 parts:

• Export family data with DynamoBIM
• Read exported family data from a Website

First, a DynamoBIM script batch opens Revit families in a directory to export FBX models, 3D Views as images, and a JSON with parameter information.

Second, we used vanilla HTML and JavaScript to read all output coming from Revit and organize it in a web page. We made it as simple as possible without using any frameworks or servers. In fact, the site does not look very pretty for the same reason. Check out the website here.

There are many use cases for this. The main intention is to avoid opening Revit to review families. From this work, other ideas can derive such as, creating a family browser of the OOTB Revit content per release. Also, the same can apply to your company's family library.

The script, "ExtractFamilyDataFromDirectory.dyn" has been tested in Revit 2020 and DynamoBIM 2.3. There is one python node that does most of the heavy lifting to avoid custom packages. The main idea is to loop through a directory of families to batch open them and while opened perform a series of tasks in the family editor programmatically. Those series of tasks can be exporting alphanumeric or geometry data as well as adding new parameters to the family.

This experiment has not been tested extensively and you should used it with care and under your own risk. For instance, it may not work with 2D families. If all of that is fine with you, clone the repo below and have fun.

GitHub - summonidea/summon-family-browser

Contribute to summonidea/summon-family-browser development by creating an account on GitHub.

GitHubsummonidea

Notes: Delete the content under the "output_families" folder and feel free to add new family files to the "input_families" folder. Also, in Dynamo, directory paths will need to be updated to be in the context of your local machine. Finally, use VSCode to run "index.html" via Open with live Server.

Design coordination requires high efficacy at problem solving, modeling, and communications. Turnaround times are short and constrained. One example is delivering slab penetrations before pouring the next level. In the following post, we will share a DynamoBIM script to dimension Plumbing Raisers (Pipes) to the closest 2 grid lines in the 2d view.

As you can tell from the image above, the script is small. The strategy was to:

• Select model elements of desired category, pipes, in this case. Then, find the X, Y location of the model elements filtered.
• Find the points of intersection formed by the grid lines itself to calculate the closest intersection to each model element (Pipe).
• Pair each model element with the two closest grid lines. Points of intersection help to map the two grid lines that make up for the intersection.

Download the script and sample Revit file from the Github repository.

summonidea/dimension-pipe-to-closest-grid-lines

Dimensions Pipes to Grid lines using DynamoBIM. Contribute to summonidea/dimension-pipe-to-closest-grid-lines development by creating an account on GitHub.

GitHubsummonidea

This script creates spot elevations on pipes using DynamoBIM. First, it collects all pipes from the active view and place a spot elevation at the highest point of the pipe. The location of dimension text is relative to the point. Clockwork package is used to get curves from pipes and create the spot elevation.

Clone the repository below to download DynamoBIM script.

summonidea/create-spot-elevation-on-pipe

Create spot elevation at the highest point of pipes - summonidea/create-spot-elevation-on-pipe

GitHubsummonidea

Just a little experiment placing rotated rectangles on an i by j grid. Rotation and color of the rectangle fill is influenced to the location (i, j) on the grid.

Code available in the link below. Enjoy!

p5.js Web Editor

A web editor for p5.js, a JavaScript library with the goal of making coding accessible to artists, designers, educators, and beginners.

Coding a little portion of a corner case on mesh generation algorithm.

p5.js Web Editor

A web editor for p5.js, a JavaScript library with the goal of making coding accessible to artists, designers, educators, and beginners.

The most common answer in the internet refers to the calculation of the acute angle between two vectors using the formula below:

\( \cos \theta=  \dfrac{u \centerdot v}{\text{\textbardbl}u\text{\textbardbl} \text{\textbardbl}v\text{\textbardbl}}\)

This calculation does not provide with the sign of the angle between two vectors. For instance, you could be interested in calculating the angle measured only in the clockwise direction. Also, this can be adapted to get the angle from 0 to 360 degrees.

Play with the code here:

p5.js Web Editor

A web editor for p5.js, a JavaScript library with the goal of making coding accessible to artists, designers, educators, and beginners.

This is a little P5.js drawing that generates a linear equation from 2 known points. The sliders at the bottom modify the X and Y values for each point. A line is formed between the 2 points. The linear equation is available in the top left corner of the canvas.

Spoiler alert: It does not work when X1 == X2 because we cannot divide by zero when calculating the slope, m.

Click on the link below and try the code yourself.

p5.js Web Editor

A web editor for p5.js, a JavaScript library with the goal of making coding accessible to artists, designers, educators, and beginners.

Problem statement: 2 out of 5 times I run a complex Dynamo graph, the program crashes.

The probability of getting exactly k successes in n independent Bernoulli trials is given by the probability mass function:

\( P(x) = \begin{pmatrix} n\\ x \end{pmatrix} p^xq^{n-x}\\ P(x) = binomial\ probability\\ x = number\ of\ times\ for\ a\ specific\ outcome\\ n = number\ of\ trials\\ p = probability\ of\ success\ on\ a\ single\ trial\\ q = probability\ of\ failure\ on\ a\ single\ trial\\ \)

What is the probability of crashing the program twice in the next 3 runs?

\( P(X=2) =  \begin{pmatrix} 3\\ 2 \end{pmatrix} 0.4^2 {(0.6)}^{3-2} = 0.288 = 28.8\% \)

What is the probability of NOT crashing the program in the next 3 attempts?

Come on! It's not a miracle. It's definitely more than that.

\( P(X=0) =  \begin{pmatrix} 3\\ 0 \end{pmatrix} 0.4^0 {(1-0.4)}^{3-0} = 0.216 = 21.6\% \)

It can also be interpreted as: probability of NOT crashing the program at any of the 3 trials

\( P(X=0) = 0.6 * 0.6 * 0.6 = 0.216 = 21.6\% \)

What is the probability of crashing the program at least once in the next 3 runs?

It could be seen as the probability of crashing the program 1, 2 OR 3 times.

\( P(X=1) =  \begin{pmatrix} 3\\ 1 \end{pmatrix} 0.4^1 {(0.6)}^{3-1} = 0.432 = 43.2\% \)

\( P(X=2) =  \begin{pmatrix} 3\\ 2 \end{pmatrix} 0.4^2 {(0.6)}^{3-2} = 0.288 = 28.8\% \)

\( P(X=3) =  \begin{pmatrix} 3\\ 3 \end{pmatrix} 0.4^3 {(0.6)}^{3-3} = 0.064 = 6.4\% \)

And, add them up:

\( P(X\ge1) = 0.432 + 0.288 + 0.064 = 0.784 = 78.4\% \)

Also, more elegantly, it can be interpreted as: 1 minus the probability of NOT crashing the program at any of the 3 trials. Trial 1: does not crash, Trial 2: does not crash Trial 3: does not crash.

\( P(X\ge1) = 1 - (0.6 * 0.6 * 0.6) = 1 - 0.216 = 0.784 = 78.4\% \)

What is the probability of crashing the program at least twice in the next 3 runs?

It is the probability of crashing 2 OR 3 times

\( P(X=2) =  \begin{pmatrix} 3\\ 2 \end{pmatrix} 0.4^2 {(0.6)}^{3-2} = 0.288 = 28.8\% \)

\( P(X=3) =  \begin{pmatrix} 3\\ 3 \end{pmatrix} 0.4^3 {(0.6)}^{3-3} = 0.064 = 6.4\% \)

Adding them up:

\( P(X\ge2) =  0.288 + 0.064 = 0.352 = 35.2\% \)

I found a very nice Binomial distribution calculator based on GeoGebra. Check the link below:

Binomial Distribution Image Generator

Binomial Distribution Image Generator

/u/michael+borcherdsGeoGebra

Adding KaTeX to a blog post:

Easily Add LaTex Math to a Ghost Blog

This is a guide to get LaTex math to work on a Ghost Blog. I chose a fast JavaScript Library developed by Khan Academy called KaTex. To see it in action, check my previous blog post on P-NP. Here are the steps to get it working: Login to the Ghost

Yoonsik ParkYoon's Blog

I have been playing with Processing and it is a lot of fun! There are a lot of resources and inspiration available if you search for creative coding or generative art. Most of the examples are made with Processing or its alternative for the web, P5.js.

I skimmed through Casey Reas and Ben Fry's book, Processing: A Programming Handbook for Visual Designers, Second Edition. I thought I bought it, but by mistake I actually ended up renting it out. So, I just returned it. This book helped me to understand the basic and advanced features of the software. Once I get an idea of what the possibilities are, I find it easier to create.

After playing with Processing for a short period of time, I wanted to start posting some outputs. Even-though it is possible to export outputs as images, videos or the application itself for Windows and Linux, I wanted it to be more web friendly. P5.js is an open-sourced JavaScript library for creative coding that is based on Processing and backed by the same community. This sketching library allows to play on your the browser.

Finally, I hope that I can share below the code and output by using Ghost's OBO snippets to embed content. (That was the entire reason to switch from Processing to P5 and I am about to test it)

Performance Note: Processing beats P5.js at rendering and keeping up with the frame rate

var p = 0;

function setup() {
  createCanvas(400, 400);
  
}

function draw() {
  //background(220);
  //noFill();
  
  rect(0, 0, p * width, p * height);
  rect(p * width, p * height, (1 - 2 * p) * width, (1 - 2 * p) * height);
  rect(width - (p * width), height - (p * height), p * width, p * height);
  
  //p = p * 1.01;
  p = p + 0.01;
  if (p > 1){
    p = 0;
  }
}

Click the link below to try the code yourself

p5.js Web Editor

A web editor for p5.js, a JavaScript library with the goal of making coding accessible to artists, designers, educators, and beginners.

This post saved me from getting disappointed: https://ghost-o-matic.com/iframes-side-by-side/

This is a DynamoBIM script that generates raised access flooring from a polygon. The first 2x2 ft. flooring panel aligns to the longest side of the polygon. From that point, it generates a grid of 2x2ft that covers the polygon entirely getting the number of panels required and the layout of the ones that need to be cut.

Because the vertices of the grid are known, they serve as reference points for pedestals. By offsetting those points in the z-axis, we get the height of pedestals. Also, the sides of the 2x2 ft. panels can work as a reference lines for stringers.

We used the offset points to place a line based family as pedestals in Revit. A floor family was used for the panels. I am not sure if having hundreds of floating floors is the best way to represent panels, but it can be swapped by other family category. Stringers are not yet considered in the model creation.

More design rules need to be implemented to warrantee the constructability of the raised floor generated output, for instance, minimum size for panels, minimum distance between pedestals, edge pedestals vs edge profiles.

Link to Github repo

summonidea/summon-raised-access-flooring

This is a DynamoBIM script that generates raised access flooring from a polygon - summonidea/summon-raised-access-flooring

summonideaGitHub

I like to play with parametric models  in DynamoBIM from time to time. When I stop doing them I miss them. But, when I work on them too much, I dislike how easily we can get a bad case of over-constrainpation. Then, what is left to do for Refinery? ;)

This is a work in progress. I worked on it because I was crunching numbers for a real estate investment and I thought it would be good to have a Dynamo definition of a simple corner case for a drive-thru.

Clone the repository from GitHub

summonidea/parametric-drive-thru

This is sample parametric model for a drive-thru development - corner option made with Dynamo Core 2.0.4.0 - summonidea/parametric-drive-thru

summonideaGitHub

In the previous blog post, we created a console application that extracts the Part Atom XML from a Revit family. This XML contains information from the family such as, name, category, update date, and active type parameters. Some Commercial content management software have a way around this to show all parameters. This is not really important in the context of this experiment.

I tried to convert the console app into a WPF app manually without any luck, but I found out the hard way that it is easier to start a WPF application from scratch and copy the functions over the new solution/project. After just a couple of tweaks, I was back in business.

Quickly enough I had to get used to data binding in order to present XML content on the UI form. My first test was just to get the XML and bind it to a text block in the form.

We are going to try to keep learning and building this up to show family types and its parameters.

Follow the development from the Repo.

Links

summonidea/summon-family

WPF application that reads the Part Atom XML from a Revit family - summonidea/summon-family

summonideaGitHub

The first time I was introduced to UNIFI labs, the family parameter extraction and category classification feature caught my attention. Just recently, I saw a post that suggested that we can unzip a Revit file (family or model) with 7-zip. See image below. Then, it was easier to explore and understand how Revit files are packaged. Later, as I kept reading about the topic, I found out that The Building Coder had discussed this topic 10 years ago! There are a couple of examples on Github for Revit plugins to read informational data from Revit content.

The example below is console app in C# that does not run on top of Revit. It reads a Revit family line by line until if finds the beginning and the end of the PartAtom XML that contains the family information. There are other ways to extract that XML string, but this was the most efficient I found. It finally console prints family information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Xml;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Program
{

    class Program
    {  

        static void Main(string[] args)
        {
            //excecution time start
            var watch = new System.Diagnostics.Stopwatch();
            watch.Start();

            string path = @"C:\familyName.rfa";
            //Extract AtomXml from Rfa
            string atomXml = ExtractAtomXmlFromRfa(path);
            //Console.WriteLine(atomXml);
            
            //initialize XML document class from string
            XmlDocument xmlDoc = new XmlDocument();
            //load XML
            xmlDoc.LoadXml(atomXml);
            //rfa <entry> element
            XmlNode root = xmlDoc.DocumentElement;

            //Display the contents of the child nodes.
            PrintXmlNodes(xmlDoc);

            //dynamic jsonText = JsonConvert.SerializeXmlNode(xmlDoc);
            //JObject json = JsonConvert.DeserializeObject<JObject>(jsonText);

            //foreach (JProperty property in json.Properties())
            //{
            //    property.Children();
            //    Console.WriteLine(property.Name + " - " + property.Value);
            //}

            //excecution time stop
            watch.Stop();
            Console.WriteLine($"Execution Time: {watch.ElapsedMilliseconds} ms");

            Console.ReadKey();
        }


        /// <summary>
        /// Reads line by line and Extracts AtomXML from revit family file
        /// </summary>
        /// <param name="path"></param>
        /// <returns>string</returns>
        static string ExtractAtomXmlFromRfa(string path)
        {        
            //define variables
            string startString = "<?xml";
            string endString = "</entry>";
            string chunks = "";
            string xml = "";
            bool startStringFound = false;
            bool endStringFound = false;

            StreamReader streamReader = File.OpenText(path);

            while ((!startStringFound || !endStringFound) && !streamReader.EndOfStream)
            {
                string line = streamReader.ReadLine();
                Byte[] lineByte = Encoding.ASCII.GetBytes(line);
                string lineEncoded = Encoding.ASCII.GetString(lineByte);
                //Console.WriteLine(lineEncoded);
                if (lineEncoded.Contains(startString))
                {
                    //Console.WriteLine("start string {0} found in the following line:\n{1}", startString, lineEncoded);
                    startStringFound = true;
                }
                if (startStringFound)
                {
                    chunks += lineEncoded;
                    if (lineEncoded.Contains(endString))
                    {
                        //Console.WriteLine("end string {0} found in the following line:\n{1}", endString, lineEncoded);
                        int startIndex = chunks.IndexOf(startString);
                        int endIndex = chunks.IndexOf(endString);
                        xml = chunks.Substring(startIndex, endIndex + endString.Length - startIndex);
                        //Console.WriteLine(xml);
                        endStringFound = true;
                    }
                }
            }
            //XmlDocument xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(xml);
            return xml;
        }
                
        /// <summary>
        /// Prints in console Xml elements and Inner text
        /// </summary>
        /// <param name="node"></param>
        static void PrintXmlNodes(XmlNode node)
        {            
            if (node.HasChildNodes)
            {
                for (int i = 0; i < node.ChildNodes.Count; i++)
                {
                    XmlNode inode = node.ChildNodes[i];
                    if (node.ChildNodes[i].FirstChild != null)
                    {
                        if (node.ChildNodes[i].NodeType == XmlNodeType.Element && node.ChildNodes[i].FirstChild.NodeType == XmlNodeType.Element)
                        {                            
                            int parentCount = NodeParentCount(node.ChildNodes[i], 0);
                            Console.WriteLine(new String('=',parentCount) + " " + node.ChildNodes[i].LocalName);
                            PrintXmlNodes(node.ChildNodes[i]);
                        }
                        if (node.ChildNodes[i].NodeType == XmlNodeType.Element && node.ChildNodes[i].FirstChild.NodeType == XmlNodeType.Text)
                        {
                            int parentCount = NodeParentCount(node.ChildNodes[i], 0);                           
                            Console.WriteLine(new String('=', parentCount) + " " + node.ChildNodes[i].LocalName + " : " + node.ChildNodes[i].InnerText);
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine("ELSE");
            }
        }

        /// <summary>
        /// Counts the number of parents that a XML node is nested in
        /// </summary>
        /// <param name="node">XmlNode</param>
        /// <param name="count">int initial counter. Usually, 0</param>
        /// <returns>int</returns>
        static int NodeParentCount(XmlNode node, int count)
        {            
            if (node.ParentNode != null)
            {
                count++;                
                return NodeParentCount(node.ParentNode, count);                
            }
            else
            {
                return count;
            }
        }
    }
}

You will see a commented snippet where I try to convert XML to JSON. I found out the execution time was slower when doing the conversion.

I created a github repository that may evolve in the future:

summonidea/rfa-atomxml-reader

Console app that reads AtomXML file of Revit family files. - summonidea/rfa-atomxml-reader

summonideaGitHub

Enjoy!

Links

https://thebuildingcoder.typepad.com/blog/2009/11/extract-part-atoms.html

Setting up the work environment

To be honest, the world does not really lack of node-express-mongo tutorials. This is just a simple exploration to setup a server, listen to a request, save a record to a database, and trigger an action.

Assuming that Node.js has already been installed (if not, download and install), first, we need to set up a folder for our little experiment. Next, we need to initiate npm inside that directory.

npm init

That 'init' command will help you to configure the project.  When you see the prompt, 'entry point', it refers to the name of the file that you will call later to run the server. We can enter index.js(or any other name) or just press enter if index.js is already the default suggestion.

entry point: (index.js)

When the project is created, after going through the prompts, there will be a package.json file in the project directory. That file contains the information that you just entered. It will also record the libraries we will install later, it will define how we run our application depending on the environment and more. But, we do not have to worry about that for now.

Let's install Express.js, the library that will help us to create our app listening to a port for external requests.

npm install express

This action will get recorded in the package.json file under dependencies.

Also, there will be a new folder in our directory called node_modules where, from now on, the libraries we install will get downloaded to.

Creating an Express app

Create a new file called index.js in your project directory

Copy and paste the code below. This is the Expressjs hello world example:

//import libraries
const express = require('express')

const app = express()
const port = 3000

//routing
app.get('/', (req, res) => {
  res.send('Hello World!')
})

//listening to port
app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`)
})

Save the file and using the command line run your server by executing the following command.

node index.js

If you type http://localhost:3000/, in your web browser, you will see the Hello World! response. Also, the console will show: Example app listening at http://localhost:3000/

Now, we know how to respond to the client when they go a certain route in the app. In this case, the route is '/'. This usually translates to render HTML on the client side or send back data in a different shape.

Next, we will learn how to receive a data from the client side.

Receiving data from the client

It is very common for a user to submit data through forms. Those forms usually have a submit button and that button is probably sending a POST request to the server. Thus, we will add a route to resolve POST requests for the root route '/'.

app.post('/', function (req, res) {
  res.send('Got a POST request')
})

The argument 'req' is the one receiving data inside its body. If I try to console.log(req.body) the payload that the client sent to the server, we get an "undefined" meaning that Node.js needs to translate it.

app.post('/', function (req, res) {
  console.log(req.body)
  res.send('Got a POST request')
})

To parse it, we can use: express.json()

app.use(express.json())

express.json vs bodyParser.json

Saving to a database

We are going to use MongoDB to create a database, a collection and save as document. Install MongoDB. Also, we will need to install the Mongoose library.

npm install mongoose

Import Mongoose to your code and connect to the local database.

const mongoose = require('mongoose');

Connect to DB

//Connect to DB
mongoose.connect('mongodb://localhost/test', {
    useNewUrlParser: true, 
    useUnifiedTopology: true});
const db = mongoose.connection;

Create an schema

//Schema constructor
const mySchema = new mongoose.Schema({
  key: String,
  property: String
});

Create a model

//Create a model
const myModel = mongoose.model('my-collection', mySchema);

Pass the data from the client and save it to the DB.

app.post('/', function (req, res) {
  const doc = new myModel(req.body)
  doc.save()
  res.send('Got a POST request')
})

Now, if we send a POST request, it will send the body below and save it to the DB.

By sending a POST request, an action has been triggered, saving a document to a DB, but we can add more after that one inside app.post.

Execute a command

The command will execute a desktop program (Notepad) using the 'child_process' library

npm install child-process

Github Repo

summonidea/rvtmodel-collab-server

Setup of a server to listen to a POST request, save a record to a database, and trigger an action - summonidea/rvtmodel-collab-server

summonideaGitHub

Links

https://expressjs.com/en/starter/installing.html
https://expressjs.com/en/starter/hello-world.html
https://expressjs.com/en/starter/basic-routing.html
http://expressjs.com/en/api.html#express.json
https://mongoosejs.com/docs/