Sean (Mar 02 2020 at 15:09): Sean (Mar 02 2020 at 15:09):Came across this today: https://medium.com/@taying.cheng/understanding-real-time-3d-reconstruction-and-kinectfusion-33d61d1cd402
starseeker (Mar 03 2020 at 12:49):Wonder what license his code is using?
starseeker (Mar 03 2020 at 12:49):Don't see one on github
Sean (May 15 2020 at 19:53):Interesting use of OSPRay: http://www.sci.utah.edu/publications/Wan2020a/TAMR_final.pdf
Sean (May 20 2020 at 15:27):Not exactly research, but this is one of the coolest uses of dll injection that I've seen in a long time: http://kylehalladay.com/blog/2020/05/20/Rendering-With-Notepad.html
Sean (Jun 11 2020 at 02:47):http://cfg.mit.edu/content/inversecsg-automatic-conversion-3d-models-csg-trees
Sean (Jun 11 2020 at 02:47):https://kevinkaixu.net/papers/wu_sgp18_csg.pdf
Sean (Jun 11 2020 at 02:48):Looks like EUGP would have probably accepted @starseeker's paper
Sean (Jun 11 2020 at 03:19):or siggraph asia, apparently. nice paper.
Sean (Jul 18 2020 at 00:15):Saw this machine showcased a couple years ago. Nice to see them making progress: https://www.digitaltrends.com/news/kamp-c-3d-printed-building/
Sean (Aug 04 2020 at 18:44):Not exactly research, but relevant to coding research, came across this interesting SIMD wrapping library: https://github.com/simd-everywhere/simde
Sean (Aug 14 2020 at 17:13):All of the High Performance Graphics 2020 sessions were posted to YouTube: https://www.youtube.com/channel/UCj04DHvbrUbuShWKzcTVJqg
Sean (Aug 24 2020 at 19:36):Interesting paper on more robustly converting a point cloud to mesh, using deep learning
Sean (Aug 26 2020 at 18:17):impressive denoising: https://www.sciencedirect.com/science/article/pii/S0010448520300506
starseeker (Aug 27 2020 at 19:49):@Sean is this of any potential interest for bu_malloc and friends? https://github.com/mjansson/rpmalloc
Sean (Aug 27 2020 at 23:23):it sounds similar to the memory allocator I wrote a couple years ago for libbu's small memory allocation. would be interesting to compare their performance since that's what our performance-critical code calls into.
Sean (Aug 27 2020 at 23:27):not sure how useful it would be for bu_malloc in general, though. I've already weeded most of the calls out, only a couple outliers. (if it's performance critical, the best solution is to avoid allocating, you allocate before processing which takes no time)
Sean (Aug 27 2020 at 23:28):the only place I know of that's production memory hungry we've not optimized is opennurbs and it's already got an allocator slot to override the standard allocator -- that's back to comparing against the BU_GET/PUT small memory allocator and I bet it'd be close to a wash.
Sean (Aug 27 2020 at 23:29):when I implemented that allocator, jemalloc was the fastest I profiled and my numbers were about as higher as this one is claiming.
Sean (Aug 27 2020 at 23:30):@starseeker unrelated, just talked to jeff the past hour. sends his regards. he noticed all the github thrashing with the uploads, I gave him the low down.
Sean (Aug 27 2020 at 23:31):fwiw, the latest ospray has a pretty cool superbuild option in their build logic that is nearly identical to what we've been talking about. the superbuild downloads and does all their dependencies before it does ospray itself.
Sean (Aug 28 2020 at 00:07):wow, and it actually worked flawlessly straight out of a cloning, including 7 significant dependencies
starseeker (Aug 28 2020 at 00:57):Nice! What do they do about ispc?
starseeker (Aug 28 2020 at 00:57):That was the really tough nut last time I looked at that bootstrap problem.
starseeker (Aug 28 2020 at 00:59):Hah! Hadn't heard from jeff in a while, but I've been following his github star traffic - I think he's scared up about a dozen small things I'd like to check out at some point.
starseeker (Aug 28 2020 at 00:59):My regards to him if you should chat again. Maybe we can get him to poke his nose into BRL-CAD + Ospray again once we're on github...
starseeker (Aug 28 2020 at 01:05):Ah, OK - they're just downloading the ispc binary
Erik (Oct 15 2020 at 23:01):soo apparently there's a high performance low level GPGPU abstraction named HIP and AMD went all out on and ported a solid impl for nvidia/cuda (amd wants into the hpc datacenter bigtime, and they're swinging hard with those epyc's, I'm lurvin' my dual 7702). I wonder if that will possibly supplant and/or supplement opencl?
Sean (Oct 20 2020 at 03:19):probably supplement if I had to wager a guess. link to it?
Erik (Oct 22 2020 at 00:10):https://rocmdocs.amd.com/en/latest/Programming_Guides/HIP-terminology.html is some, I forgot where I saw the thing that got me looking
Sean (Oct 22 2020 at 21:13):oh I like dat table tho
starseeker (Nov 16 2020 at 15:56):https://www.sciencedirect.com/journal/softwarex
Sean (Nov 17 2020 at 19:08):oh, that is interesting! thanks @starseeker
Sean (Nov 17 2020 at 19:08):a certain visibility calculation that I've been working on seems super appropriate there
Sean (Nov 24 2020 at 17:21):https://www.khronos.org/blog/vulkan-ray-tracing-final-specification-release
starseeker (Dec 03 2020 at 14:19):http://graphics.cs.uos.de/bezierguarding.html looks at first glance like something I was trying to do in a more ad-hoc fashion during the meshing work... code is MIT licensed too.
starseeker (Dec 03 2020 at 14:37):https://ranahanocka.github.io/point2mesh/
Sean (Dec 04 2020 at 02:12):The first paper is out of my depth without study.
Sean (Dec 04 2020 at 02:14):The second paper is almost the same shrinkwrapping method I've mentioned we could/should probably implement before, only using a neural net to pull the points in intelligently instead of using an ant-crawling algorithm to walk the mesh points inward.
Sean (Dec 04 2020 at 02:16):That latter is also a great example of something that we should continue to work towards -- they use blender as the processing engine similar to how we use mged.
starseeker (Dec 04 2020 at 03:40):I see the infrastructure they are using is heavily python based - I wonder what it would take to recode the core elements of the algorithm on top of something like tensorflow's C API...
starseeker (Dec 04 2020 at 03:47):Heh - this one goes the other way, in to out: https://www.cs.bgu.ac.il/~asharf/Projects/BLOB/index.htm
Sean (Dec 04 2020 at 03:48):That's what I was referring to - blender's interface is a python one akin to how ours is tcl
Sean (Dec 04 2020 at 03:49):I think our ged interface is considerably more powerful design than what blender exposes, and easier to use, but they're geared for different things.
Sean (Dec 04 2020 at 03:50):it would be interesting to study and see if we could find some alignment
starseeker (Dec 04 2020 at 03:55):oh, you're talking about the use of python rather than implementing the point2mesh feature?
Sean (Dec 04 2020 at 03:56):yeah, the interface and methodology, not necessarily this particular use case.
starseeker (Dec 04 2020 at 03:56):Ah. My mistake. I was thinking we wanted the feature
Sean (Dec 04 2020 at 03:56):this particular use case is of course very interesting in its own right. It would be cool to implement what they're doing in c++
Sean (Dec 04 2020 at 03:57):I didn't see anything terribly complicated in there.
the hardest bits would probably be the hooks it's using in blender
starseeker (Dec 04 2020 at 03:59):Unless I'm misunderstanding there's an extensive python ecosystem in back of this - pytorch, meshcnn, pytorch3d...
Sean (Dec 04 2020 at 04:02):that's how most python works... even simple things can be an extensive ecosystem of plugins and "libraries"
starseeker (Dec 04 2020 at 04:02):/me should probably take some classes on CNN/DNN - I know virtually nothing about it
Sean (Dec 04 2020 at 04:02):it's actually nice that the project's code is relatively simple, so each call entry could be tackled fairly independently
Sean (Dec 04 2020 at 04:03):you should, it's awesome stuff. AI was a specialty of mine in undergrad. Did a lot with all kinds of NNs before they became a thing everywhere.
starseeker (Dec 04 2020 at 04:05):I'll have to look at that paper more closely - visually, their initial mesh looks like a decimation of the convex hull but I'm not sure what criteria they used to set it up...
Sean (Dec 04 2020 at 04:06):I still like GAs more, but NNs get sh!t done fast. Eventually, a GA+NN will replicate every aspect of human neural processing.
Sean (Dec 04 2020 at 04:07):yeah, that's what I saw too. get a convext hull and then do some sort of CNN transform on the points to pull them in intelligently.
starseeker (Dec 04 2020 at 04:07):is tensorflow still the 800 pound gorilla in the field?
Sean (Dec 04 2020 at 04:07):tensorflow is the jungle
starseeker (Dec 04 2020 at 04:08):<chuckle> Me thinks their dev team should drive around with that on a bumper sticker...
Sean (Dec 04 2020 at 04:09):you may find the basic concepts are usable even without the NN's, you could just do what they're doing and when it comes to the decision point where it calls into the NN, you just do the naive decision.
Sean (Dec 04 2020 at 04:09):plus, you can use the NN without tensorflow or whatever else
Sean (Dec 04 2020 at 04:09):tensorflow lets you build and evolve NNs. They presumably aren't training an NN -- they trained one and are using it I think
Sean (Dec 04 2020 at 04:10):so you could use the one they came up with. it's likely encoded in there somewhere.
starseeker (Dec 04 2020 at 04:12):I suspect I lack the background to follow that part... the implication I got was they were somehow using the point cloud to guide the CNN
Sean (Dec 04 2020 at 04:12):they most certainly are
starseeker (Dec 04 2020 at 04:13):So there's another model of some sort they would have created in advance?
Sean (Dec 04 2020 at 04:13):NNs are really just super basic inputs-to-output functions. so it's probably set up as feed points in, get points out.
Sean (Dec 04 2020 at 04:14):the black box is what to do to the points, and that's typically trained in some manner
starseeker (Dec 04 2020 at 04:15):self-prior is a term specific to NN then? That's one of the bits I haven't decoded yet...
starseeker (Dec 04 2020 at 04:17):Oof. Got to pack it in for the evening - back tomorrow.
Sean (Dec 04 2020 at 04:22):Nah, that's just some package's variable naming if I had to guess. self is a python thing. prior probably refers to a previous convolution of the neural net (happens during training)
Sean (Dec 04 2020 at 04:24):self in python is similar to 'this' in C++
Sean (Dec 04 2020 at 04:26):it's just a convention for a particular class scope so you can access member variables and functions, so there's apparently one called "prior"
starseeker (Dec 07 2020 at 23:33):https://www.phoronix.com/scan.php?page=news_item&px=Zink-OpenGL-3.3-Mesa-20.3
starseeker (Dec 18 2020 at 19:16):https://people.unica.it/gianmarcocherchi/files/2020/09/fast_and_robust_mesh_arr.pdf
https://github.com/gcherchi/FastAndRobustMeshArrangements
Sean (Mar 12 2021 at 18:23):This classic was recently made available!
An-Introduction-to-Ray-Tracing-The-Morgan-Kaufmann-Series-in-Computer-Graphics-.pdf
starseeker (Mar 12 2021 at 18:24):Cool!
starseeker (Mar 29 2021 at 01:20):Fast Exact Booleans for Iterated CSG using Octree-Embedded BSPs
https://arxiv.org/pdf/2103.02486.pdf
starseeker (Mar 29 2021 at 01:21):I think those researchers are working at the same place that puts out openflipper/openmesh - wonder if they could be enticed to look at applying that approach to our facetization problem...
starseeker (Jul 25 2021 at 17:43):https://github.com/potato3d/instancing
Jared McLaughlin (Jul 28 2021 at 14:22):Fascinating.
starseeker (Aug 02 2021 at 03:59):https://web.cse.ohio-state.edu/~dey.8/paper/tcocone/tcocone.pdf
starseeker (Aug 02 2021 at 04:18):https://hal.inria.fr/hal-01596553/file/CAD17.pdf - says they have an open source implementation in GEOGRAM
starseeker (Aug 02 2021 at 15:01):humph. need to boil it down to the pieces we can use without license incompatible deps, and see if that's got enough to be of use. Oh well, a project for another day...
starseeker (Aug 02 2021 at 18:46):Note to future self - to trigger reconstruction, this is the command:
vorpalite profile=reconstruct t.xyz rebuild.obj
Works with default write output from pnts command.
Sean (Sep 17 2021 at 04:46):This is an interesting one... looks like someone studied BRL-CAD and performed a UML relationship diagram deconstruction of the system: http://eprints.library.odeku.edu.ua/id/eprint/6217/1/VelykodniySS_Reengineering_open_software_2019.pdf
Dashamir Hoxha (Sep 17 2021 at 08:49):Sean said:
This is an interesting one... looks like someone studied BRL-CAD and performed a UML relationship diagram deconstruction of the system: http://eprints.library.odeku.edu.ua/id/eprint/6217/1/VelykodniySS_Reengineering_open_software_2019.pdf
Despite the goal of the paper (reengineering BRL-CAD), I think that light-weight UML diagrams could be useful for documenting the structure of the code.
By the way, my preferred UML tool is UMLet.
Sean (Sep 18 2021 at 05:35):That professor actually wrote five papers on brl-cad
I'm not sure his intent was actually to re-engineer as much as it was to simply study it
Sean (Sep 18 2021 at 05:36):Exchanging some messages with him, maybe get some collaboration going
Sean (Apr 05 2022 at 16:17):From Siggraph 2021, interesting new approach to representation: https://github.com/duxingyi-charles/Boundary_Sampled_Halfspaces
starseeker (Jul 23 2022 at 06:42):Cool, I hadn't realized mistuba's newer implementations were using a liberal license now: https://github.com/mitsuba-renderer/mitsuba3
Sean (May 19 2023 at 20:12):Wow, now that's impressive... https://github.com/XingangPan/DragGAN
Sean (Jul 10 2023 at 05:25):Generating CAD models from engineering sketchs (and point clouds and meshes, and more):
https://www.eurchembull.com/uploads/paper/d17bb7ba2b4030974b08506d707c6a70.pdf
Sean (Jul 10 2023 at 05:28):and https://www.semanticscholar.org/reader/57d71b30f2ff68bde4a0c50322bb93a5c3358ee0
Sean (Jul 10 2023 at 05:49):not to forget this related gem from siggraph 2022: https://geometry.cs.ucl.ac.uk/group_website/projects/2022/free2cad/
all siggraph 2022 talks and papers are at https://blog.selfshadow.com
Sean (Jul 12 2023 at 04:04):Fun writeup from someone that got a Siggraph paper accepted a couple years ago. Paper is even related to our work, implicit rendering on gpu: https://www.mattkeeter.com/projects/siggraph/
starseeker (Jul 12 2023 at 23:39):Sounds kind of interesting from a "point cloud scans to CAD" perspective: http://www.cs.columbia.edu/cg/deepcad/
Sean (Feb 27 2024 at 18:50):starseeker said:
Sounds kind of interesting from a "point cloud scans to CAD" perspective: http://www.cs.columbia.edu/cg/deepcad/
That's definitely interesting to me! Not so much for the drafting approach, but the underlying generation. I think the same concept would extend well to CSG and/or NURBS.
Sean (Feb 27 2024 at 18:51):Here's a couple more papers that just came out of CVPR 2024:
stable mobile-device SLAM algorithm:
https://spla-tam.github.io
constructing CAD from point clouds:
https://www.obukhov.ai/point2cad
Sean (Apr 17 2024 at 16:59):Very interesting HPC-tuned math library: https://bitbucket.org/blaze-lib/blaze/src/master/
Has me thinking about the old effort to implement fastf_t as a c++ class, how this might be a means to simdify huge swaths of code.
starseeker (Apr 17 2024 at 17:47):That does look interesting. Heh - I suppose I'd get to find out where I've goofed and used double explicitly instead of fastf_t if we did something like that...
Himanshu (Apr 17 2024 at 18:43):Sean said:
Very interesting HPC-tuned math library: https://bitbucket.org/blaze-lib/blaze/src/master/
Has me thinking about the old effort to implement fastf_t as a c++ class, how this might be a means to simdify huge swaths of code.
Does BRL-CAD uses something like this? Or what's behind BRL-CAD fast math calculation?
Last updated: Oct 09 2024 at 00:44 UTC