Okay, our next speaker is going to be talking to us about canned query, and the canned query,
this is the new free function API for a canned query.
One of the lead authors of canned query, this is a critical piece of software for certainly
for keycad, but I know for a number of other programs as well, so please give a warm welcome
to Adam.
Okay, thank you, so let's start.
So, what is canned query?
Well, it's a Python package for parameter feed modeling.
It is based on a variable kernel, so it's not CSG or not Efra, it doesn't use implicit's,
and we can import an export existing canned notice using step, right?
So, up to now, we like to have it on fluent APIs, and there are some random models
that you can make with it.
So, here is also a brief overview of the dependencies and modules in canned query, so we
are focusing on this part, and also we have our own, let's say, custom binding to open
casket, which is the beer kernel underlying canned query.
All right, so maybe let's keep the capabilities given the time constraints, but I say,
they are quite extensive, and we support many file formats for reading and writing.
So, yeah, and the talk is about the feed function API, and let's first contrast it with
fluent APIs, what it was, what it used to be before.
So, here's a random example that I'm going to step through, import, define some parameters,
and we, and say, construct this fluent statement or blow up of lines.
And it is a times, again, but the times is also somewhat difficult, maintain and read, right?
So, that's the motivation to develop something else.
Either way, this code results in such a model, and it's reasonably compact.
And the new thing goes like this.
Obviously, we have a module, and then step by step, we define the entities, and every, let's say,
a statement here has no implicit state, right?
Just functions that I'm calling, and defining certain, let's say, the cat objects.
And I use certain operations like extrude, fillets, here's a Boolean cat, another Boolean cat,
with an extrusion, to obtain the final model, and this is the final model that we get, right?
So, the same thing.
So, you can clearly see that it is more verbose, but on the other hand, you're more explicit,
and more precise in, let's say, defining the operations, which is, in the end, for complicated models, quite handy.
So, some key points of this new API.
So, as I said, no hidden state, we are operating on, shape objects on the, let's say, lowest level objects,
in calculate it represents cat entities.
All primitive are created using three functions, and so are all operations.
And also for convenience, Boolean observance implemented as a operator.
So, we can either use a function or an operator to do cats and whatnot, which results,
and ends in more redo code, not necessarily in better performance.
And, last but not least, we can now use selectors on shapes.
That's also a new addition.
It's not, this is the last but least.
Objects are placed and ready to get using moved.
So, we can, let's say, create arrays in copies and whatnot on the design locations.
And, one additional point that you need to keep in mind is, for some operations,
or let's say, we're reasonably applicable, they're multiple overloads provided.
So, sometimes it makes sense to work on the list of shapes or, or some other thing or compounds,
and usually both of those are provided.
So, let's see.
So, we can, that's also an important point.
We can use this refraction.
We can assemble higher order typological objects, shapes, solids from lower order typological objects.
So, we can, let's say, sample wires to edges, or edges to wires, faces to wires to faces, and faces to solids.
And, this allows really a lot of freedom to construct models.
And, sometimes, allows to optimize the way Boolean operations, which are extremely slow.
And, good.
We have more time, so we don't need to rush.
Oh, it's a timeshow.
Okay, okay, okay, okay.
So, yeah, actually, we have, let's say, this capability, we can assemble shapes, step-for-step, right?
And that allows, sometimes, to get rid of Boolean operations, to optimize them way,
because they are usually the bottleneck in modeling, or additional, in cascade.
So, yeah, this is an example of doing so.
So, let's, we start with two circles, right?
We define, in this case, a bottom face by lofting, between two circles, right?
And then, define the sides by extruding the set circles.
And then, again, we define certain top face by lofting.
The initial two circles with some additional edge, I don't know, visual for that.
But, either way, then we construct a solid, as I mentioned.
And, this is the, this is what we get, right?
So, of course, in a particular example, but, maybe, we say some time, but, by not, let's say,
we're not using Boolean operations for, say, define the center hall and the top shape.
So, that's also handy.
What more, yeah, there are some more additions like, we can now check for correctness.
It's a, it's a, it's a quite extensive check.
Also, tries to detect self intersections and returns.
If, as to, returns the errors that your shape has.
And, of course, we can also mix and match with the existing APIs.
So, we can add our shapes to work plane, to sketch, and then we can, on the other hand,
convert back from work plane or sketch to shape.
And, assembly is to always support the direct, of assembly of objects, objects, meaning shapes.
So, this is the current state of the three-function PI, ball.
The idea is to stabilize it a little bit and polish, based on experience.
So, I'm personally using it quite extensively.
It also results in some, let's say, additions.
But I would like to hear also about other people to say about it.
Certainly would like to add local operations.
So, sometimes you can, again, save time by not using Boolean operations,
but certain, let's say, variety of operations that only take into account the local entities' faces.
And, another important point is, if you model a complicated object,
we want to have some history.
So, there is a support for that in the kernel.
We'd like to expose that also in the free-function PI.
Some other additions would require quite many, let's say, quality of life improvements in the latest release,
not related to the function PI, so I'm just, it's a quickly stepping for those.
So, we have many additions to shape, regarding the geometry.
So, let's say, journey guidelines, normals, sampling and whatnot.
There are these new special methods added to work when in sketch.
So, they allow to write as a quick extension, without suppressing those objects.
And, also, other additions like, okay, Boolean operations are now uniformly supported operators.
So, for work plane and sketch, I think it used to be the case only for work plane.
In the previous releases, we can iterate easily, and you can also, for work plane work with selected faces, this will be only wires.
So, this also handy, although some lower-level details.
Okay, and one more important addition, I would like to pitch a little bit is,
actually used to be already in the previous release release.
We have built-in visualization, right?
It's really handy for, let's say, ad hoc debugging.
Also, if you're doing interactive debugging, as if you put a break on summer,
you can use it. So, that's super useful.
And, now it is extended to support other, let's say, objects.
So, you can visualize, let's say, locations, points, lists of locations, points.
And, if you're into VDK, you can, let's say, visualize any VDK actor.
So, you can, let's say, use this also for applications involving ad hoc machine,
or use VDK's underlying, let's say library.
Okay, this is a lot of text.
This has looks.
So, here again, we have shapes, the locations, points.
And, in that VDK actor, that's also works.
And, this is how it looks in Jupyter.
So, one additional point was that there was also a repository built in support for rendering in Jupyter.
So, it's all, let's say, it's supposed to work in various use cases,
without additional tools, although there are many.
And, that is it on visualization.
I usually like to add, or add a slider to about the processing categories.
So, this time is kind of interesting.
So, it's actually used for designing nucleophishing vectors.
Here we have an example of magnate shapes.
As you can see, this is quite complicated shapes.
So, rather difficult to mold those with, let's say, conventional case.
We have to use some kind of programmatic approach for modeling.
So, you have this right, right, you have to use,
probably something else in the conventional case, right.
To get these kind of shapes.
So, here's all yet another visual of plasma and ceramic layers.
So, yeah, let's say, I suppose, let's say, I did not initiate this,
but I suppose using this kind of tool for in this application is,
let's say, an necessity because of the organic nature of the shapes.
Alright, now I have too much time, I suppose.
So, how to support us?
Well, I would really like to hear about some interesting work,
and these are examples for get's query, right.
It's actually quite difficult sometimes to get to know what people are doing.
So, I know more interesting, as an example from the industry,
but only via via, so, no specifics.
If you use it for scientific work,
there are quite some papers, suddenly,
also a lot of papers.
I'll say, using category with LNs, but anyways,
we do have a generic DUI, so please use it if you are into,
let's say, publishing scientific papers.
And if you're feeling rich, and have something interesting to develop,
I think we're also open for a sponsor development of new features.
Alright, so, let's sum up.
So, I think it's available, that's a pre-functional device,
for addition to category.
I'm using it extensively now, and I must say,
I do enjoy the experience, although I obviously bias, right.
It will be continued, the development of the API will be continued, right.
And the expectations should be stable soon,
so, next release, or maybe we can do releases.
And there are some other features that are, I'll say,
in a conceptual preparation for the time being, but,
so, number one is integration of category of machine tools.
So, if you have those complicated models,
then usually you want to use the first simulation,
and then you need to do a well-meshing,
and then there's the question of, let's say,
establishing or transferring metadata,
which phase belongs to which, let's say, phase in your mesh.
And the other thing is, actually, based on experience,
there are many rough corners in open cascade.
So, for certain, for certain modeling applications,
it's actually necessary to develop your own functionality.
And it would be quite handy to have, like,
a geometry, like, independent terms geometry layer in category.
So, I think it will be, it will be developed in some form,
not as extensive as open cascade,
but something that would allow to quickly,
and say, implement certain algorithms.
So, yeah, this is it.
This is actually all slides.
I did speed up a little bit at the beginning, so,
I'm sure we should handle it.
But, anyway, it's almost gone.
So, thank you.
So, you were, I think, to some selection of shape or forget exactly.
What does it mean exactly?
Because you have already, you've already objected in a variable name,
so, what does this feature bring to it?
This selection of selected selector.
Okay, yeah.
So, this question is, essentially, what are selectors in category?
Okay.
So, I guess we can go to this example here.
Let's go here.
So, yeah.
There you go.
So, for example, for certain operations,
I have this object here, right?
And I do want to do a transfer on the top face, right?
So, I need to select the top face,
and the shape object and other objects in category
have specific special methods for selection of,
it will be quantities.
So, there is a, like, there's like a DSL,
and also, let's say,
bit maps to select the objects for acquiring the geometry.
So, in this case, I have this guy, right?
And I want to get a reference to the top face.
So, I say, okay, please select faces,
and this higher than Z means, well, top.
So, that's essentially, so,
selectors are methods for selecting,
top.go entities in your model.
Hi.
First of all, thank you very much for doing this.
Really appreciate it.
Thank you.
Moving forward.
Do you plan on the fluent API to stay
a first-class citizen of category?
Okay.
So, question was, is the fluent API a few to stay?
And that's, yes, yes.
There is no plans to deprecate it or remove it or not.
So, that's sort of the assurance, yes.
Thank you very much for your talk.
One, two questions for the show command is there an option
to set the viewpoint of the model,
or is there, like, individual possibility to manually rotate
the part after showing it.
And second question is, what possibilities do I have to export
the result to some file later on?
Okay.
So, two questions.
One is, is the built-in visualization interactive?
I think this is the, the, the, the, the, the, the, the, the, the, the, the, the,
the answer is, yes, it is.
So, actually,
I say,
doing this or re-hawking show is blocking, right?
So, it starts an event loop and it, it is interactive
so you can manually let's say, rotate it and,
I say, inspect what you have.
And the other question was,
yeah, what are the, what are the file formats or how do I export?
So, uh, it's, uh, briefly, uh,
I briefly mentioned, but, uh, but yeah, it's a list here,
uh, actually, it's not a full list, but, for, let's say, the most important
formats, right? You, for lossless, uh,
um, exports, you do have the built-in open task platform on the
breadth and, uh, for interoperability with catals,
you can do step or, uh, for to the, uh, for
the first application entity itself. So, that is it.
Uh, yeah, so, uh, this cat query is going to be
installable by pip, uh, but CPU editor is not.
Yeah.
Uh, and does this interactive visualization require something
that is not installable outside conduct?
Uh, do, do, do, do, do, do, do, do, do, do, do, do, do,
do, does the visualization require dependencies that are not
pip installable? Uh, not as far as I know, uh, so, uh,
uh, we are here, right? So, actually, it is just, uh, using
the decay for visualization and that as far as I know, is
pip installable. Um, so, I think this answer.
It is this.
Just a complete equation if I make a pip installable,
I can play again for the dependency.
Uh, as far as I know, yes, I know there are, uh,
there can be issues, right, but it should work.
In Christmas York, yeah.
Thank you for the talk. I'm new to, uh, cat query.
Uh, but I'm very familiar to, uh, open scar.
Uh, could you give me a gift of, uh,
why cat query came to exist in comparison to other
programmatic, uh, like, cat tools?
Okay, so, uh, briefly questions why, what was the motivational
patent category, uh, given that other, uh, let's say,
so, through cat tools existed. Um, so, let's say,
and, and specifically open scar. So, open scar is, is,
is, is, not based on a bureau panel, right?
Uh, so it uses, uh, I think,
meshes for modeling. So, there is no way you can, uh,
uh, let's say, as far as I know, it's not possible to get,
I step forward a bit, and that's more or less,
the son of a way of, of, let's say,
exchanging cat information, um,
to the main motivational, as I didn't create the project, right?
It was, I think, day if you created it. So, I don't know,
his main motivational, but I suppose, um,
there were not so many tools that were really focused on
programmatic cats that used, uh, a bureau panel.
So, that, that's, that's, that's it, essentially.
Okay, thank you very much, Alan.
Thank you.