<whitequark>
heekscnc is basically slicing (waterline) + hsm generation within each layer
<wpwrak>
haven't looked much at solvespace yet. the premise sounds promising, though
sandeepkr__ has quit [Ping timeout: 255 seconds]
<wpwrak>
can it extrude along an arbitrary path ? i.e., if you wanted to make some sort of bucket, with a chamfered edge between bottom and walls, could you just define the cross-section (which may look a bit like http://solvespace.com/pics/tut-section-done.png), then move it along a path to make the bucket ?
<wpwrak>
or would you need to break this down into straight line segments and do something else for (rounded) corners ?
<whitequark>
unfortunately not, the only 2d-to-3d operations it has is extrude along a line and rotate around axis
<whitequark>
well, in case of a round bucket specifically it's not a problem
<whitequark>
but if you want an elliptic bucket with chamfered edges... basically you're out of luck
<wpwrak>
yeah, i was thinking of a more artistic bucket :)
<whitequark>
this is a rather known problem. the current plan is to plagiarize opencascade
<whitequark>
i.e. not drag in the whole thing with its horrible dependencies, but just take the relevant NURBS operations out of it and reimplement
<whitequark>
this should be doable in a reasonable amount of time *and* we get the only other FOSS NURBS operations library
<whitequark>
and, well, we don't get opencascade as a dependency, too
<whitequark>
other things i'd like to get sorted out is proper dxf export (with splines, annotations and such), *any* import (dxf at first), and editing more than one sketch at once, with propagation across inclusions
<whitequark>
the former is going to land any day now
<whitequark>
the last one requires massive, multi-month refactoring
<whitequark>
but as a side effect you'll be able to drive the geometric kernel from python, headless
<wpwrak>
what would be so bad about having opencascase as dependency ? do they break the APIs often ?
<whitequark>
and also get parameterized sketches, eg Mn screw with variable N
<whitequark>
opencascade is an extremely large C++ codebase that is given away because the holding company is charging for consulting
<whitequark>
so they have no incentive to make it usable
<whitequark>
so it would be dragging in a million or so LOC of shit for a feature that's at most a few thousand LOC
<whitequark>
and then translating everything back and forth
<whitequark>
the problem is NURBS booleans. they have an annoyingly large set of edge cases and basically no library takes it onto itself to handle them all
<whitequark>
in principle it's possible to do everything using just meshes, but you don't get exact fits, and worse, you cannot infer features to constrain against from geometry itsefl
<whitequark>
since you don't get the algebraic representation of them
<whitequark>
that said, actually not all results of NURBS booleans can be represented exactly either
<whitequark>
wpwrak: anyway, i'd be quite interested in your feedback. you could use SS for something minor anelok-related
<whitequark>
ditto for DocScrutinizer05
<whitequark>
wpwrak: I was also thinking about PCB import. not sure about formats though, never used them so far
<wpwrak>
what wuold be useful are just basic parameter input/output operations. so that one can write one's own wrappers. e.g., to import component positions from a pcb. or vice versa.
<whitequark>
yes, a SWIG interface exposed to Python or Lua is another priority
<wpwrak>
whatever swig is :) i was more thinking of just gnuplot-style input/output data sets :)
<whitequark>
well, solvespace is in a C++, and SWIG is a binding generator
<whitequark>
s/a//
<qi-bot>
whitequark meant: "well, solvespce is in C++, nd SWIG is binding genertor"
<whitequark>
qi-bot: stupid bot
<whitequark>
wpwrak: with the current file format you can do it yourself.
<whitequark>
try looking at it with `less`
<whitequark>
I'm going to migrate it to a binary format, since the current one is monstrously inefficient even on tiny models
<whitequark>
though the current one will remain readable forever anyway
<wpwrak>
mmh, but aren't things calculated from parametric input ? you'd want the calculation results (for further processing), not the parameters from the source
<wpwrak>
the format is a bit chatty (*) but doesn't look too inefficient
<wpwrak>
(*) e.g., you could just remove "Entity" and such and use a global parameter space. then AddEntity et al. would read that global space and clear it. voila, saves a bunch of redundancy
<wpwrak>
(and it's still line-by-line processor friendly :)
<whitequark>
entities and mesh are only written from imports
<whitequark>
you only actually need params, requests and constaints
<whitequark>
constraints*
<whitequark>
however, imported sketches aren't resolved, so the complete result is written.
<whitequark>
only written FOR imports.
<whitequark>
that said the format is actually a direct serialization of the internal data structures
<wpwrak>
mmh, so you're saying that it contains the parametrized model and the results of processing it ?
<whitequark>
exactly.
<whitequark>
Entity.actPoint is the numeric result
<whitequark>
that said I'm pretty sure a proper Python/Lua interface and a way to run it in batch mode is what you *actually* want
<whitequark>
instead of a heap of ad-hoc hacks over an undocumented file format exposing internals
<whitequark>
I know, not user-hostile enough to be unix-way...
sandeepkr__ has joined #qi-hardware
pcercuei has quit [Quit: bbl]
Ornoterm1s has quit [Ping timeout: 240 seconds]
Ornotermes has joined #qi-hardware
pcercuei has joined #qi-hardware
pcercuei has quit [Client Quit]
kristianpaul has quit [Quit: Reconnecting]
kristianpaul has joined #qi-hardware
kristianpaul has joined #qi-hardware
pcercuei has joined #qi-hardware
tumdedum has quit [*.net *.split]
tumdedum has joined #qi-hardware
archang has quit [*.net *.split]
kanzure has quit [*.net *.split]
kanzure has joined #qi-hardware
archang has joined #qi-hardware
jwhitmore has quit [Ping timeout: 276 seconds]
rjeffries has quit [Read error: Connection reset by peer]
kanzure has quit [Changing host]
kanzure has joined #qi-hardware
rjeffries has joined #qi-hardware
alexst has joined #qi-hardware
rjeffries has quit [Remote host closed the connection]
rjeffries has joined #qi-hardware
sandeepkr__ has quit [Ping timeout: 276 seconds]
alexst has quit [Ping timeout: 252 seconds]
alexst has joined #qi-hardware
alexst has quit [Ping timeout: 240 seconds]
<DocScrutinizer05>
whitequark: congrats and thanks for the fine news. I guess Neo900 could use it for stacking a PCB sandwich with only a 2.5mm headroom between PCB surfaces so height_a + height_b of components < 2.5mm, quite a requirement for layout resp component placing prior to layout
pcercuei has quit [Quit: leaving]
<whitequark>
DocScrutinizer05: hmmm that needs IDFv3 import, right?
<DocScrutinizer05>
whitequark: xslt etc comes to mind as alternative to lua/python binding, but of course a binding is waaay more powerful, particularly when it not only allows .get but also call of arbitrary object methods
<whitequark>
yes, it will allow arbitrary sketch modification
<whitequark>
and it's actually less work than xslt
<DocScrutinizer05>
(IDFv3) I haven't even looked into it, not even pondered any details how to handle it at all
<whitequark>
kicad exports placement data into IDFv3
<DocScrutinizer05>
yeah, prolly that's a first take on it
<DocScrutinizer05>
I wouldn't even dare to think about interactive integration yet
<whitequark>
I'm currently evaluating that actually
<DocScrutinizer05>
particularly as long as Neo900 is Eagle based
<whitequark>
ahhh right
<whitequark>
yeah eagle has idf export too but interactive is a nonstarter
<DocScrutinizer05>
I seem to reecall sth about IDF export in eagle as well
<whitequark>
it uses an ULP plugin
<DocScrutinizer05>
yep, exactly
<whitequark>
actually not *impossible* to do import but incredibly fragile and tedious
<DocScrutinizer05>
yes
<DocScrutinizer05>
ULP is rather powerful but icky
<DocScrutinizer05>
particularly ULP doesn't allow any modification calls to objects
<whitequark>
ULP is actually one of the least bad homegrown EDA languages I've seen
<whitequark>
yes
<whitequark>
you're supposed to generate an SCR
<whitequark>
it's understandable, they don't want to duplicate all the consistency checking code for ULP too
<DocScrutinizer05>
you do idiotic things like producing a script of macros that gets called after ULP quits
<whitequark>
since they already have it for the GUI and separately for SCR
<whitequark>
caught in their own bad design
<DocScrutinizer05>
hehe, yes
<whitequark>
so, hm, I've read most of IDFv3 spec
<whitequark>
it's a good, sane format
<whitequark>
problem is it assumes an 1:1 correspondence between IDF file and ECAD/MCAD internal repro
<whitequark>
for bidirectional integration
<DocScrutinizer05>
repetitve switch beween scr and ulp with mutual calls feels like worst 1978 coding hell
<whitequark>
I feel like I could do something like that after all
<whitequark>
it'd just be a fairly awkward mapping to a generic MCAD, parametric too
<whitequark>
and, well
<whitequark>
what do you even do with with things you can't store in IDF like constraints?
<DocScrutinizer05>
right
<DocScrutinizer05>
it's a complex problem, not easy to come up with a architecture for
<whitequark>
so like, just importing IDF in a representation you can constrain against is pretty easy
<DocScrutinizer05>
possibly
<whitequark>
no, certainly, it has a straightforward mapping
<whitequark>
I already know how I'd do that
<DocScrutinizer05>
generate a "zone file" overlay that devines allowable component height
<DocScrutinizer05>
defines even
<whitequark>
are you talking ECAD->MCAD or MCAD->ECAD?
<DocScrutinizer05>
the latter right now
<whitequark>
ah yeah
<DocScrutinizer05>
so during layout and component pos I can check against such layer
<DocScrutinizer05>
but stuff gets funny when I want to arrange stuff on the other surface to make space on this surface
<DocScrutinizer05>
it's like the antique turtle race
<whitequark>
yeah
<whitequark>
so the IDF format is based around outlines
<whitequark>
it can specify a bunch of outlines, which are just loops defined by points+curvature
<whitequark>
not even bezier
<whitequark>
and every outline has some other properties like "component name" "board side" "locked by MCAD/ECAD" etc
<whitequark>
that's it
<whitequark>
that's the whole format
<DocScrutinizer05>
yes
<DocScrutinizer05>
shouls suffice
<DocScrutinizer05>
component height particularly
<whitequark>
I can simply map those outlines to MCAD outlines
<whitequark>
and when there's a height you make an extrusion
<whitequark>
and all other operations except for drawing outlines on top/bottom and extrusion are disallowed
<DocScrutinizer05>
then you calculate the free space headroom aka 2.5mm - component_height_a and inport that as restriction layer for survace_b in layout editor
<DocScrutinizer05>
and vice versa whenever switchin to surface_a layout
<DocScrutinizer05>
sorry, I can tell from my typos that I'm still asleep
<DocScrutinizer05>
ideally you could export two sets of component objects incl height, for surface a and b and arrange components *in* SS so they all mechanically fit, then export both to eagle and see if you can do reasonable layout with that placement
<DocScrutinizer05>
inside eagle there's no editor for such stuff
<DocScrutinizer05>
where you could see collisions instantly
<DocScrutinizer05>
in SS you could edit placement for both surfaces and instantly see and fix collisions
<DocScrutinizer05>
(if I actually understood what's SS)
<whitequark>
not quite immediately "both" because I only know how to map *one* IDF file to a sketch
<whitequark>
but soon SS will learn how to edit two sketches at once
<whitequark>
right now you could only do stuff like: create two sketches from two IDF files, import two sketches into one assembly
<whitequark>
then: edit sketch, reload assembly
<whitequark>
even in two windows side by side
<whitequark>
but it's not quite as convenient as having it builtin
<whitequark>
basically the problem is relative positioning of imported IDF files against each other, they both want to be at origin
<whitequark>
which is why assembling is needed
<whitequark>
like for any other two parts
<DocScrutinizer05>
yes :-)
<whitequark>
mhm this still needs import and export though... or more like IDF editing mode that also saves SS metadata somewhere
jwhitmore has joined #qi-hardware
alexst has joined #qi-hardware
<DocScrutinizer05>
I wonder if a ULP could actually calculate allowable height vor a component at a particular given place in realtime, but here realtime is a sad joke because you need to manually trigger ULPs and it wouldn't help for moving components around
<DocScrutinizer05>
I also wonder why I always use v insted f
<DocScrutinizer05>
not awake, as I said
alexst has quit [Client Quit]
<DocScrutinizer05>
((repetitve switch beween scr and ulp)) just had a nightmare daydream flash of SCR storing parameters into component properies, then calling next ULP segment aka file aka card. "Luckily" that's nonsense since SCRs have no conditionals so they are 100% deterministic and if they're not due to errors then there's no way to call an ULP conditionally
<DocScrutinizer05>
ULP would indeed work rather fine if it hadn't this idiotic limitation of actions to chainloaded SCR which turns writing useful ULP into a coder's nightmare
<DocScrutinizer05>
I guess a ULP - for a particular component X on surface A - could go through all components C on surface B and check if their (C.height > (2.5mm - X.height)) and any of of C's frame coordinates is within the frame of X
<DocScrutinizer05>
but then what to do with the result?
<DocScrutinizer05>
change color of C?
<DocScrutinizer05>
move C into an arbitrary direction so there's no more collision?
<DocScrutinizer05>
write a marker rectange (or whatever shape of component X) into layout of surface B, highlight or focus the component C and jump into editor with the component already picked for moving?