DataCube

Der DataCube ist unser erstes Haptic Bytes Modell. Er stellt vielleicht die reinste Form digitale Informationen in physischer Form zu enkodieren dar: Man nehme eine digitale Erinnerung, berechne einen Hash derselbigen, und speichere sie in einer dreidimensionalen Matrix von n*n*n Bits.

Unser Code um DataCubes zu generieren ist als Open Source Software verfügbar. Alle können das Modell demnach frei anpassen, ansehen, modifizieren und generell damit Spaß haben.

Du kannst DataCubes ganz einfach direkt hier in deinem Browser ausprobieren! Drücke einfach den [Zufälligen DataCube generieren!]-Button, um DataCubes aus Zufallsdaten zu generieren. Die generierten Cubes können im 3D-Viewer darunter betrachtet, gezoomt und rotiert werden.

Um deinen eigenen, personalisierten DataCube aus einer digitalen Erinnerung zu generieren, wähle zunächst eine Datei von deinem PC (über den Auswahldialog oder per Drag&Drop). Drücke dann den [Generieren!]-Button. Deine Datei wird eingelesen und durch unseren Algorithmus in einen einzigartigen DataCube verwandelt. Der so generierte DataCube wird mit sehr großer Wahrscheinlichkeit in unserer Lebenszeit kein zweites mal exakt so existieren, wenn du den normalen 5x5x5 Cube verwendest: 5x5x5 Bits bedeutet dass der Cube 125 Bit Information enthält; es gibt also 2¹²⁵ (oder grob 4.2535296e+37, oder 42 Sextillionen – eine Zahl mit 38 Stellen) mögliche, verschiedene 5x5x5 Cubes.
Wichtig: Das Alles passiert komplett in deinem Client (also in deinem Webbrowser, auf deinem Computer), ohne dass irgendwelche Informationen über dich oder die Datei(en) aus denen du Cubes generierst an unsere Server (oder sonstige Dritte) übermittelt werden. Wir verwenden außerdem keinerlei Cookies (auch keine sog. Tracking-Cookies) in irgendeiner Form auf dieser gesamten Website.

Die einzige Information, die an unseren Server geht, ist ein winziges Paket mit der alleinigen Information "Es wurde gerade ein neuer DataCube generiert". Wir nutzen das nur, um einen groben Überblick über das Interesse an diesem Projekt zu erhalten. Wir wissen und verfolgen ansonsten rein gar nichts über dich, die Datei(en) die du wählst, was darin enthalten ist, oder was du mit generierten Cubes anstellst.


// vim: set syntax=javascript:

function getParameterDefinitions() {
    return [
        { name: 'gen_support', caption: 'Generate supports?', type: 'choice', values: ["No", "Yes"], default: "No", captions: ['No', 'Yes']}, 
        { name: 'sw', caption: 'Thickness of the supports:', type: 'float', default: 0.4},
        { name: 'size', caption: 'Length of one side of the cube:', type: 'int', default: 100 },
        { name: 'ft', caption: 'Thickness of the outer frame:', type: 'int', default: 5 },
        { name: 'st', caption: 'Thickness of the struts inside the cube:', type: 'float', default: 1.2 },
        { name: 'n_cols', caption: 'Number of columns/rows/levels of the cube:', type: 'int', default: 5},
        { name: 'bit_h', caption: 'Height of one "bit":', type: 'int', default: 12},
        { name: 'bit_w', caption: 'Width of one "bit":', type: 'int', default: 8},
        { name: 'fr_offset', caption: 'Height offset (for better bridges):', type: 'float', default: 0.2 }
    ];
}

function frame(rsize, rft, fr_offset) {
    var far = [
        // bottom square
        CSG.cube({ center: [0,-(rsize-rft),-rsize+rft], radius: [rsize, rft, rft]}),
        CSG.cube({ center: [0,rsize-rft,-rsize+rft], radius: [rsize, rft, rft]}),
        CSG.cube({ center: [-(rsize-rft),0,-rsize+rft], radius: [rft, rsize, rft]}),
        CSG.cube({ center: [rsize-rft,0,-rsize+rft], radius: [rft, rsize, rft]}),

        // top square
        CSG.cube({ center: [0,-(rsize-rft),rsize-rft-fr_offset], radius: [rsize, rft, rft+fr_offset]}),
        CSG.cube({ center: [0,rsize-rft,rsize-rft-fr_offset], radius: [rsize, rft, rft+fr_offset]}),
        CSG.cube({ center: [-(rsize-rft),0,rsize-rft], radius: [rft, rsize, rft]}),
        CSG.cube({ center: [rsize-rft,0,rsize-rft], radius: [rft, rsize, rft]}),

        // pillars
        CSG.cube({ center: [-rsize+rft,-rsize+rft,0], radius: [rft, rft, rsize]}),
        CSG.cube({ center: [rsize-rft,-rsize+rft,0], radius: [rft, rft, rsize]}),
        CSG.cube({ center: [-rsize+rft,rsize-rft,0], radius: [rft, rft, rsize]}),
        CSG.cube({ center: [rsize-rft, rsize-rft,0], radius: [rft, rft, rsize]})
    ];

    fr = far.pop();
    return fr.union(far).setColor([0,0.263,0.412]);
}

function struts(rsize, ft, sep, rst, n_cols) {
    var sar = [];
    
    // top and bottom struts
    var i;
    for (i=0; i<n_cols; i++) {
        // bottom
        sar.push(CSG.cube({ center: [0,-rsize+ft+i*sep+sep,-rsize+rst], radius: [rsize, rst, rst] }));
        // top
        sar.push(CSG.cube({ center: [0,-rsize+ft+i*sep+sep,rsize-rst], radius: [rsize, rst, rst] }));
    }

    // vertical struts
    var j;
    for (i=0; i<n_cols; i++) {
        for (j=0; j<n_cols; j++) {
            sar.push(CSG.cube({ center: [-rsize+ft+i*sep+sep,-rsize+ft+j*sep+sep,0], radius: [rst, rst, rsize] }));
        }
    }

    // more horizontal struts
    for (i=0; i<n_cols; i++) {
        for (j=0; j<n_cols+1; j++) {
            sar.push(CSG.cube({ center: [-rsize+ft+i*sep+sep,0,-rsize+ft+j*sep+0.5*sep], radius: [rst, rsize-sep-ft, rst] }));
            sar.push(CSG.cube({ center: [0, -rsize+ft+i*sep+sep, -rsize+ft+j*sep+0.5*sep], radius: [rsize-sep-ft, rst, rst] }));
        }
    }

    st = sar.pop();
    return st.union(sar).setColor([0,0.263,0.412]);
}

function bits(data, rsize, ft, sep, n_cols, bit_h, bit_w) {
    var bar = [];

    var bit = CSG.polyhedron({
        points: [ [0,0,bit_h/2], [0,0,-bit_h/2], // top/bottom points
                  [-bit_w/2,-bit_w/2,0], [-bit_w/2,bit_w/2,0], [bit_w/2,bit_w/2], [bit_w/2,-bit_w/2] // other points
                ],
        faces:  [ [0,5,2], [0,2,3], [0,3,4], [0,4,5], // top half
                  [1,2,5], [1,3,2], [1,4,3], [1,5,4]  // bottom half
                ]
    });

    bar = [];
    count = 0;
    var i; 
    var j; 
    var k;
    for (i=0; i<n_cols; i++) {
        for (j=0; j<n_cols; j++) {
            for (k=0; k<n_cols; k++) {
                if (data[count]) { // bit is one
                    bar.push(bit.translate([-rsize+ft+sep+i*sep, -rsize+ft+sep+j*sep, -rsize+ft+sep+k*sep]));
                }
                count++;
            }
        }
    }
    
    bi = bar.pop();
    return bi.union(bar).setColor([1, 0.121, 0.545]);
}

function support(rft, sw, size, rsize, ft, sep, n_cols) {
    
    var sup = CAG.fromPoints([[-rft,-rft],[rft,rft],[rft,rft+sw],[-rft,-rft+sw]])
        .extrude({offset: [0,0,size-2*ft]})
        .translate([0,0,-rsize+ft]);
    
    var hsup = CAG.fromPoints([[ft-rft-rsize+sep, rft], [rft+rsize-2*ft-sep, rft], [-ft+rft+rsize-sep, -rft], [rft-rsize+ft+sep, -rft]])
        .extrude({offset: [0,0,sw]})
        .translate([-0.5*sw,0,0]);
        

    var supar = [];
    var i;
    // vertical supports
    for (i=0; i<n_cols; i++) {
        supar.push(sup.translate([-rsize+rft, -rsize+i*sep+sep+ft-sw*0.5, 0]));
        supar.push(sup.translate([rsize-rft, -rsize+i*sep+sep+ft-sw*0.5, 0]));
        supar.push(sup.rotateZ(90).translate([-rsize+i*sep+sep+ft-sw*0.5, -rsize+rft, 0]));
        supar.push(sup.rotateZ(90).translate([-rsize+i*sep+sep+ft-sw*0.5, rsize-rft, 0]));
    }

    // horizontal supports
    for (i=0; i<n_cols; i++) {
        supar.push(hsup.translate([0,-rsize+rft,-rsize+ft+sep+i*sep]));
        supar.push(hsup.translate([0,+rsize-rft,-rsize+ft+sep+i*sep]));
        supar.push(hsup.rotateZ(90).translate([-rsize+rft, 0, -rsize+ft+sep+i*sep]));
        supar.push(hsup.rotateZ(90).translate([rsize-rft, 0, -rsize+ft+sep+i*sep]));
    }
    
    sups = supar.pop();
    return sups.union(supar).setColor([0.859,0.122,0.282]);
}

function main(params) {
    
    var us = params.size - 2 * params.ft;
    var sep = us / (params.n_cols+1);
    
    var data = [];
    var numOfCubeBits = params.n_cols*params.n_cols*params.n_cols;
    var i;
    for (i=0; i < numOfCubeBits; i++) {
        data.push(Math.round(Math.random()));
    }
    // the following line can be replaced to overwrite data if a DataCube with custom data should be generated
    /* REPLACEME */

    DataCube = frame(params.size/2, params.ft/2, params.fr_offset).union(struts(params.size/2, params.ft, sep, params.st/2, params.n_cols));
    DataCube = DataCube.union(bits(data, params.size/2, params.ft, sep, params.n_cols, params.bit_h, params.bit_w));
    if (params.gen_support == "Yes") {
       DataCube = DataCube.union(support(params.ft/2, params.sw, params.size, params.size/2, params.ft, sep, params.n_cols));
    }
    return DataCube;
}

Schritt 1: Datei auswählen

Klicke [hier] um eine Datei auszuwählen, oder drag & droppe eine Datei hierhin.

Schritt 2: Klicken, um einen DataCube zu generieren

Wenn du Zugang zu einem 3D-Drucker hast, kannst du deinen personalisierten DataCube einfach selbst in unsere physikalische Welt holen: Zunächst empfehlen wir stark, Supports mit zu generieren wenn der Cube gedruckt werden soll. Erweitere hierzu die Parameters unter dem 3D-Viewer, und aktiviere die Supports. Klicke dann auf den [Update]-Button unten im Parameters-Panel. Danach kannst du deinen Cube mit dem entsprechenden Button unter dem 3D-Viewer als STL exportieren und drucken.

Eine kurze Anmerkung zu dem großen Cube der links im großen Bild zu sehen ist: Dieser DataCube (teils auch in manchen Szenen des matou makes-Videos über dieses Projekt zu sehen, war ein früher Prototyp, den wir für die 3D-Druck Challenge entworfen haben, die all das hier ursprünglich gestartet hat. Dieser Prototyp musste in mehreren Druckvorgängen gedruckt und dann manuell zusammengebaut werden. Wir dachten uns, dass ein kleineres Modell (so wie oben zu sehen), welches auf einmal gedruckt werden kann, in der Umsetzung für viele Leute einfacher ist.

Welches Material eignet sich zum 3D-Drucken von DataCubes?

Für FDM-Drucke empfehlen wir PLA, weil sich damit gut Brücken (horizontale Abschnitte ohne Support) drucken lassen. Andere Filamente die sich gut zum Druck von Brücken eignen, funktionieren ebenfalls.

Empfohlene Slicer-Einstellungen

PrusaSlicer

Wir empfehlen diesen Slicer zu verwenden, da er in unseren Tests die besten Brücken erzeugt hat.

Für manche dieser Einstellungen werden die advanced- oder sogar expert-Modi in PrusaSlicer benötigt.

Einstellung	Wert	Beschreibung (englisch)
Supports	None	We recommend using the supports that can be optionally generated directly with the model as this will save you some material. Using automatic or manual supports by the slicer should work, too; but it might be difficult to remove.
Layer height (Print Settings -> Layers and perimeters)	0.2mm-0.3mm	This has been tested with both 0.2 and 0.3 layer height, which worked great.
Detect thin walls (Print Settings -> Layers and perimeters)	Yes	This is important for the generated supports to work.
Infill	0%	The model doesn't really need infill.
Brim	As you like	A brim wasn't required in our tests. But it will help if you are having difficulties keeping the print stuck to the print bed.
Avoid crossing perimeters (Print Settings -> Layers and perimeters)	Optional	However, enabling this can increase the time for G-code generation __a lot__, especially in older versions of Prusa Slicer. Alternatively, you can also enable _Lift Z_, which also prevents the issue.
Lift Z (Printer Settings -> Extruder)	Optional	Sometimes it happens that the print head movement breaks one of the thin struts while it travels to a different position. This setting should prevent that.

Cura

Einstellung	Wert	Beschreibung (englisch)
Supports	None	see description for PrusaSlicer
Layer height	0.2mm-0.3mm	see description for PrusaSlicer
Infill	0%	No infill should be fine.
Brim	As you like	Should work without. Use if the model doesn't stick to the print bed very well.
Print Thin Walls	Yes	Important if the supports that come with the model are used as they otherwise don't print.
Enable Retraction	Yes	This goes together with the z hop setting.
Z Hop When Retracted	Yes	To avoid breaking the thin struts as the print head travels.

Bitte hinterlasse ein issue auf GitHub wenn dir irgendwelche Probleme beim 3D-Drucken generierter DataCubes auffallen.

Credits / License: To support clientside creation of DataCubes, we developed this Haptic Bytes model in OpenJsCad. OpenJsCad is developed by Joost Nieuwenhuijse and is based on initial CSG.js (copyright (c) 2011 Evan Wallace).
Uses lightgl.js by Evan Wallace and Tomi Aarnio for WebGL rendering.
Contributions by Alexandre Girard, Tom Robinson, jboecker, risacher, tedbeer, bebbi, Sahil Shekhawat.
All OpenJsCad code released under MIT license.