Tiny CAD

Tiny houses are all the rage. Yet CAD software is expensive. So let's give some people a head start on affordable housing.

Similar projects worth following
Tiny houses are all the rage. So why are there still so many homeless people? Unfortunately, as popular as the "tiny" house meme is, the bitter truth is that the construction costs can often rival that of their full-size cousins, and what might seem to start out as a five to a ten-thousand-dollar project can easily turn into a fifty to one hundred thousand dollar money pit, that is when the cost of permits (when required), materials, labor (if you aren't able to DIY) and so on are added in. Then there is the cost of CAD software. Now if you are doing work that requires a permit, you might not have any choice but to use Auto-Cad or Vector Works, but even then you might be able to save thousands if you can get a head start on your project, using open-source software - which can be used to create compatible design documents. The hardware for this project, therefore, is whatever you decide to build with it.

Thinking about a project?  Perhaps a bookcase for those encyclopedias that you inherited?  Or perhaps a shed, a new fence, or a back deck?  Every now and then I take to the notion of just "simply" building a digital replica of "my world", so to speak.  Yet obviously there is nothing simple about it, although perhaps there should be, or could be.  Given that my first personal computer was an Apple II, I obviously have some sentiment toward the simplicity of wanting to create something by drawing with simple commands like MoveTo and LineTo, FillPolygon, and so on. 

From these primitives, we should be able to build stuff.  Complicated stuff.  The original AutoCAD was really more of a programming language, based on Auto-Lisp than the more contemporary "click on this CIRCLE tool", position it with the mouse, etc., size it, and so on methodology, that we have become accustomed to.

Yet what programs like Auto-CAD and Adobe Illustrator really do, is translate mouse movements and clicks into menu item selections and numbers which then get translated into the various low-level API calls.  Yet something seems to get lost in the process, at least most of the time, for most people.  Then there are the object description languages, or file specifications really, like obj, where it is possible to specify in a file some really nice stuff, like a teapot or a bumble-bee for that matter, and get some really nice results, yet something still gets lost in the process.

Sometimes the game developers get most of it right.  Especially if you can shoot at things, blow things up, burn them down, have realistic big fish eating the little fish in your virtual aquarium, or have your virtual race car blow a tire, or an engine, and perhaps crash, with bent and mangled parts flying everywhere, and so on.

Maybe the next frontier in software is going to be to follow along the pathways that seemed to be suggested by online games like Second Life, Minecraft, etc., as well as their predecessors like Sim-City and Sim-Life, and the like.  So maybe it is time to rethink the whole process of content creation from the ground up.

Maybe I should try rewriting the code for a simple wall, and make some very minor changes so that I can also have a "simple ladder", "simple bookcase", "simple fence", and "simple deck".  Then there might be "things with drawers, or doors", or "round things", etc.

Eventually, maybe AI will do this for us, perhaps you are thinking.  Or maybe there are some not-so-open applications out there that are TRYING to do that, but they don't quite have the right set of primitives worked out, quite yet - maybe because that source code doesn't exist yet in a usable form that they can "borrow" from off of Git.  Oh, well.

Yet I also saw an example (elsewhere) of how the latest version of Photoshop can remove unwanted people or objects from a scene, which sounds like a useful feature (even if it reminds me of Stalin - obviously!) or "relocate a reindeer" from a wooded scene to a "backdrop of a dark alley', and so on.  Kind of interesting, but I have no actual need for to pay to "rent" software, like that - or Auto-CAD for that matter, just to build a bookcase, or whatever else, and where the cost of software rental might exceed the cost of the "project", turning it into a deal killer.  This has been the problem with Eagle vs. KiCAD, from what I read.  So there are plenty of people who want to make "just one project" that have no need, or desire, nor do they have the means to pay for ongoing software subscriptions.

  • Alright, Let's get the Party Started!

    glgorman06/16/2023 at 21:47 0 comments

    Here is a screenshot from a program that I have been working on for what seems like forever, and if you don't know by now, I despise Java, JavaScript, and a bunch of other madness. Well now you know, in any case.  Real programmers, IMHO program in real languages, like C, C++, Lisp, Pascal (which is a subset of ADA), and of course let's not forget FORTRAN and assembly, even if I have long since forgotten most of my FORTRAN.  Oh, well.  In any case, let's look at how I decided to lay out a simple wall in C++.

    // construct a temporary reference stud and make copies of that
    // stud as we need ... future version - make all  of the studs
    // all at once and put them in a lumber pile with painted ends
    // then animate construction appropriately.  Uh, huh - sure
    // "real soon now" ... 
    void simple_wall::layout_and_construct_studs ()
        int number_of_studs;
        _vector w1,w2;
        rectangular_prism    reference_stud (STUD_WIDTH*FEET_TO_CM,STUD_DEPTH*FEET_TO_CM,(m_height-STUD_WIDTH)*FEET_TO_CM);
        reference_stud.m_color = COLOR::yellow;
        reference_stud.m_bFillSides = true;
        m_span = _vector::length (m_end [1] - m_end [0]);
        _vector direction = _vector::normalize (m_end [1] - m_end[0]);
        reference_stud.set_orientation (0,0,arccos(direction[0]));
        number_of_studs = 1+(int)floor (m_span/(FEET_TO_CM*m_stud_spacing));    
        int k;
        for (k=0;k<number_of_studs;k++)
        w1 = m_end [0]+direction*(k*FEET_TO_CM*m_stud_spacing);
        w2 = w1 + _vector (0,0,m_height*FEET_TO_CM);
        reference_stud.set_position (_vector::midpoint (w1,w2));
        m_studs.push_back (reference_stud);
        //    this is the bottom plate and the top plate
        m_bottom_plate.m_size = _vector (m_span,STUD_DEPTH*FEET_TO_CM,(STUD_WIDTH-STUD_GAP)*FEET_TO_CM);
        m_bottom_plate.SetObjectColor (COLOR::green);
        m_bottom_plate.set_position (_vector::midpoint (m_end [1],m_end [0]));
        m_bottom_plate.set_orientation (reference_stud.get_orientation());
        m_bottom_plate.calculate_vertices ();
        for (k=0;k<2;k++) {
        m_top_plates[k].m_size = m_bottom_plate.m_size;
        m_top_plates[k].SetObjectColor (COLOR::yellow);
        m_top_plates[k].set_orientation (reference_stud.get_orientation());
        m_top_plates[k].calculate_vertices ();
        m_top_plates[k].set_position (_vector::midpoint 
        (m_end [1],m_end [0])+_vector (0,0,m_height*FEET_TO_CM));
        m_top_plates[1].m_position += _vector (0,0,STUD_WIDTH*FEET_TO_CM);

     OK - so there are about 1000 lines of this stuff, just to lay out a simple floor plan, and maybe another 30 thousand or so lines that do the tensor math stuff for the 3-d calculations, with either Open-GL or GDI-based rendering.  Haven't really put much thought into Microsoft's "Write Once Run Anywhere" concept that is supposed to be able to take C/C++ code and turn it into Java-Script, or is it TypeScript, or was that something else that I never really got into; like how some people might get DOOM running on a Cannon printer, that is with some kind of code conversion tool.

    O.K., in any case - a simple stud wall is pretty much a slam dunk.  Figuring outdoors in windows is another matter.  Then, of course, there is roofing.  Sometimes, it is much simpler to just build the real thing.  Working out gables, especially if you want a complex roof design, ouch - now we have to get into some kind of theory of intersecting planes, and which ones have priority, etc., and then there are the rafters, and the cross bracing, and so on; figuring out what intersects what.  Some things are quite easy in...

    Read more »

View project log

Enjoy this project?



Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates