grapherOptions.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_GRAPHER_OPTIONS_H
#define PXR_EXEC_VDF_GRAPHER_OPTIONS_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/grapher.h"
#include "pxr/exec/vdf/object.h"
 
#include "pxr/base/tf/hashmap.h"
#include "pxr/base/tf/stl.h"
 
#include <functional>
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfNode;
 
class VdfGrapherOptions 
{
 
public:
 
    enum DisplayStyle {
        DisplayStyleFull = 0,
        DisplayStyleNoLabels,
        DisplayStyleSummary
    };
 
    using NodeFilterCallback = std::function<
        bool (const VdfNode &nodeToFilter)>;
 
    using NodeStyleCallback = std::function<
        DisplayStyle (
            const VdfNode &node,
            const VdfConnectionVector &drawnIn,
            const VdfConnectionVector &drawnOut)>;
 
    struct NodeLimit {
        NodeLimit(const VdfNode *n, int maxin, int maxout) :
            node(n),
            maxInDepth(maxin),
            maxOutDepth(maxout) 
        {}
 
        const VdfNode *node;
        int maxInDepth;
        int maxOutDepth;
    };
 
    typedef std::vector<NodeLimit> NodeLimitVector;
 
public:
 
    VDF_API
    VdfGrapherOptions();
 
    void SetDrawMasks(bool drawMasks)  {  _drawMasks = drawMasks; }
 
    void SetDrawAffectsMasks(bool drawMasks)  {  _drawAffectsMasks = drawMasks; }
 
    bool GetDrawMasks() const { return _drawMasks; }
 
    bool GetDrawAffectsMasks() const { return _drawAffectsMasks; }
 
    void SetPrintSingleOutputs(bool enable) {
        _printSingleOutputs = enable; }
 
    bool GetPrintSingleOutputs() const {
        return _printSingleOutputs; }
 
    void SetPageSize(double width, double height) { 
        _pageWidth = width;
        _pageHeight = height;
    }
 
    double GetPageHeight() const { return _pageHeight; }
 
    double GetPageWidth() const { return _pageWidth; }
 
    void SetUniqueIds(bool uniqueIds) { _uniqueIds = uniqueIds; }
 
    bool GetUniqueIds() const { return _uniqueIds; }
 
    void SetOmitUnconnectedSpecs(bool omit) { _omitUnconnectedSpecs = omit; }
 
    bool GetOmitUnconnectedSpecs() const { return _omitUnconnectedSpecs; }
 
    void SetDrawColorizedConnectionsOnly(bool drawColorizedConnectionsOnly) {
        _drawColorizedConnectionsOnly = drawColorizedConnectionsOnly;
    }
 
    bool GetDrawColorizedConnectionsOnly() const {
        return _drawColorizedConnectionsOnly;
    }
 
    void AddNodeToGraph(const VdfNode &node, int maxInDepth, int maxOutDepth) {
        _nodesToGraph.push_back(NodeLimit(&node, maxInDepth, maxOutDepth));
    }
 
    void SetColor(const VdfObjectPtr &object, const TfToken &color) {
 
        if (!color.IsEmpty())
            _objectColors[object] = color;
    }
 
    TfToken GetColor(const VdfObjectPtr &object) const {
        return TfMapLookupByValue(_objectColors, object, TfToken());
    }
 
    void SetAnnotation(const VdfObjectPtr &object, const std::string &text) {
        _objectAnnotations[object] = text;
    }
 
    std::string GetAnnotation(const VdfObjectPtr &object) const {
        return TfMapLookupByValue(_objectAnnotations, object, std::string());
    }
 
    const NodeLimitVector &GetNodesToGraph() const { return _nodesToGraph; }
 
    void SetNodeFilterCallback(const NodeFilterCallback &callback) {
        _nodeFilterCallback = callback;
    }
 
    const NodeFilterCallback &GetNodeFilterCallback() const {
        return _nodeFilterCallback;
    }    
 
    void SetNodeStyleCallback(const NodeStyleCallback &callback) {
        _nodeStyleCallback = callback;
    }
 
    const NodeStyleCallback &GetNodeStyleCallback() const {
        return _nodeStyleCallback;
    }    
 
    VDF_API
    static bool DebugNameFilter(
        const std::vector<std::string> &nameList,
        bool includeIfInNameList,
        const VdfNode &node );
 
    void SetDisplayStyle(DisplayStyle style) {
        _displayStyle = style;
    }
 
    DisplayStyle GetDisplayStyle() const { return _displayStyle; }
 
private:
 
    // Draws the masks on the connections if true.
    bool _drawMasks;
 
    // Draws the affects masks on outputs if true.
    bool _drawAffectsMasks;
 
    // The width of the page
    double _pageWidth;
 
    // The height of the page
    double _pageHeight;
 
    // Determines whether or not unique IDs are used.
    bool _uniqueIds;
 
    // The subset of nodes to draw.  If this list is empty, everything 
    // in the network is drawn.
    NodeLimitVector _nodesToGraph;
 
    // The callback used to filter nodes out of the graph.  
    NodeFilterCallback _nodeFilterCallback;
    
    // The callback used to style nodes.
    NodeStyleCallback _nodeStyleCallback;
 
    // The display style for the nodes
    DisplayStyle _displayStyle;
 
    // If true, nodes that have a single output, will render that output.
    bool _printSingleOutputs;
 
    // Map of colored objects to color name.
    TfHashMap<VdfObjectPtr, TfToken, VdfObjectPtr::HashFunctor> _objectColors;
    
    // Map of annotated objects to annotation.
    TfHashMap<VdfObjectPtr, std::string, VdfObjectPtr::HashFunctor> _objectAnnotations;
    
    // If true, unconnected inputs/outputs will be omitted.
    bool _omitUnconnectedSpecs;
    
    // If true, draw connections with explicitly SetColor() only.
    bool _drawColorizedConnectionsOnly;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif