Queries, queries and more queries ...

ron_moreland

Here is a simple FS:

FeatureScript 736;
import(path : "onshape/std/geometry.fs", version : "736.0");

annotation { "Feature Type Name" : "FS Test" }
export const fstest = defineFeature(function(context is Context, id is Id, definition is map)
    precondition
    {
        annotation { "Name" : "Plane", "Filter" : GeometryType.PLANE || EntityType.FACE , "MaxNumberOfPicks" : 1 }
        definition.tPlane is Query;
    }

    {
        const thePlane = evaluateQuery(context, definition.tPlane);

        debug(context, "DBG1 "~ thePlane );
        debug(context, "DBG2 "~ thePlane[0] );
        if ( canBePlane(thePlane[0]) )
        {
            debug(context, "Can be a Plane");
        }
        else
        {
            debug(context, "Not a PLANE");
        }
    }

    );

and here is the debug output:

debug: DBG1 [ Query : { "queryType" : QueryType : "TRANSIENT" , "transientId" : TransientId : BuiltIn: 7 } ] debug: DBG2 Query : { "queryType" : QueryType : "TRANSIENT" , "transientId" : TransientId : BuiltIn: 7 } debug: Not a PLANE Result: Regeneration complete

I read the Docs carefully, evaluteQuery() returns an array of queries. So how do I get the things?

ilya_baran

Yes, evaluateQuery just returns an array of queries, one per entity.  To get information about an entity (coordinates, etc.) you need an ev function.  In this case, you can use evPlane to get an actual Plane.  Or you could use evFaceTangentPlane.  Or evSurfaceDefinition.  You could also tell if a query refers to any plane by wrapping it in a qGeometry query (with GeometryType.PLANE) and seeing if evaluteQuery of that gives you an empty array.

https://cad.onshape.com/FsDoc/modeling.html has a good overview of these concepts.

BTW, The way to tell if something is a plane is by doing
if (foo is Plane)
rather than
if (canBePlane(foo))

ilya_baran

Yes, evaluateQuery just returns an array of queries, one per entity.  To get information about an entity (coordinates, etc.) you need an ev function.  In this case, you can use evPlane to get an actual Plane.  Or you could use evFaceTangentPlane.  Or evSurfaceDefinition.  You could also tell if a query refers to any plane by wrapping it in a qGeometry query (with GeometryType.PLANE) and seeing if evaluteQuery of that gives you an empty array.

https://cad.onshape.com/FsDoc/modeling.html has a good overview of these concepts.

BTW, The way to tell if something is a plane is by doing
if (foo is Plane)
rather than
if (canBePlane(foo))

ron_moreland

Thank you for the reply. In your response:

if (foo is Plane)

What is "foo"? Is it an entity?  Geometry? A query? A query to an entity that might be a Plane. If you have to evaluate a query with the proper ev* to get the actual entity, how can this work if you don't know what ev* to use?

konstantin_shiriazdanov

currently the direct way of evaluation of queries doesn't exist in FS, so we have to use tests like above, you apply ev function to the query and check if the result is of type you expect - then you may do some type-specific actions with it. since there are no case/switch operator if/else tests is the best we can do.
the other solution can be using try silent {} for example:
try silent
{
p = evPlane( query)
//if evPlane doesn't fails you may perform actions with p
}
try silent
{
l = evLine(query)
//if query evaluates to line evPlane failed and you are switched to this branch of code
}

ilya_baran

@ron_moreland
In my example "foo" can be any FeatureScript value.
I would not think about it as "getting at the real entity" -- the "real" entity exists deep within the context and is impossible to "get at".  The way FS works is you describe the set of entities you want to ask about using a query and then get data about these entities using ev functions -- the Plane returned by evPlane is not tied to the planar face at all -- it's just the coordinates of that plane.

One of the reasons for this design is that operations can change the "real" underlying entities in rather unpredictable ways, e.g., splitting and merging them, changing types, etc. and trying to hold on to a specific entity would not work well.

Deciding which ev to use depends on what you're trying to achieve.  If you want to know know the type of face, for instance, evSurfaceDefinition will tell you.  evPlane is just simpler if you happen to know that you are referencing a plane (which happens frequently -- either because of you specified a selection filter in you feature's query parameter or because you just created one or because your query is a qGeometry).  Most ev functions, like evDistance or evFaceTangentPlane do not require you to know the type of geometry you're dealing with.

ron_moreland

Thanks for the patient replies. My brain is stiff, gotta stretch the synapses.