Using the tool bin vis, which simply assigns a shade of grey for each byte in a file, it’s possible to represent the structure of pieces of a file. Check it out, these are found 3D files from various software programs:
Found a cool surprise when I uploaded a .BMP file, the bytes map almost perfectly onto the image;
I want to try other uncompressed formats like RAW. Loading PNGs and JPEGs are uninteresting so far, they are just noise.
I have tried some experiments processing this data. These stem from the observation that changing the width of the viewing window, which causes the binary data to wrap around the screen, changes the representation of the data dramatically.
In this experiment I tried to adjust the window of the binary visualizing screen to get the data to make columns, to the extend that this was possible. Some of this info must repeat at a point in the middle of a byte and therefore not map onto a grid of pixels perfectly (?).
Here is an attempt to isolate just the modules which repeat in the above image and to display only them;
I am imagining a program which goes through the file and figures out the proper width for each chunk of data so that this process can be automated.
Some experiments I would like to try:
-what does the same form look like (say, a sphere) in different software formats?
-is it possible to identify which part of the binary file links up with which part of the 3D file? Could you isolate the repeating element and figure out exactly what it’s composed of?
-what are the similarities and differences between different 3D objects saved by the same software? (I.e. what is the software grain?)
-what do the Rhino.exe, Adobe Illustrator.exe and Revit.exe files look like?
-show a before and after compression image.
-somehow look at a program’s operation by examining it’s buffer memory live somehow?
and here’s the view of just the pixels in the same file just changing the window width:
Essentially each eight bits (eg. 01101001) are transformed into a pixel with a value of grey between black (0) and white (255):
I just visited the Glasgow Botanical Garden and watched the film Aquarela. Both experiences reminded me about the diversity of patterns and permutation of simple rules at play in the cosmos.
Aquerela (2019) Screenshot
Glasgow botanical gardens (image from http://martinbrookes.blogspot.com/2018/06/the-botanical-gardens-glasgow.html)
Looking at a Rhino file in a text editor you get that same “grain” feel as with bin vis:
this is from https://developer.rhino3d.com/api/RhinoCommon/html/N_Rhino_FileIO.htm
but there is also: https://developer.rhino3d.com/guides/#opennurbs
It would seem a lot easier to start with a file format that is ASCII encoded though…
This is a RAW file opened in binview, it has several images contained in it, one for each color channel I guess:
Here is a Bitmap file saved with interleave:
An IGS file format, ASCII readable, visualized. Pretty boring unfortunately.
I found a head inside an example Rhino file :D!
Some tests with a single image saved in different formats:
Zooming in to some patterns:
Some patterns I found in 3D files (would be cool to compare to image file observations!):
With red to help identify the patterns:
For comparison here are some samples from image files:
Comparing an all white vs. all black file:
Next experiment is to copy and paste pieces of one file into others. Possibly from a compressed file into a raw file! (Wait – why?)
Insight into what we’re seeing in these files: http://www.rumint.org/gregconti/publications/taxonomy-bh.pdf
when things line up into a structure, data is fixed length. When things don’t line up we get variable length data chunks. Repeating values seem to help align data regions. Nois is encrypted in some way typically which has scrambled the structure.
The problem with this visualization is that it does not represent TIME, like my other ones. It would be cool to stretch and compress these images based on the speed with which the files were written somehow.
Update: This software called HeapMemory (https://www.nirsoft.net/utils/heap_memory_view.html) allows you to see memory created by active programs. You can output the data and then visualize it with binvis. If you did this regularly while you worked on a 3D model, you could have a representation of the file you’re working on through the eyes of the computer program.
Here is a gif of a rhino operation and the change in the 3dm file:
and here’s a timelapse of a rhino file with transformations taking place: