libvtk7-dev 7.1.1+dfsg1-2 / usr / include / vtk-7.1 / vtkCollapseVerticesByArray.h

This file is indexed.

/usr/include/vtk-7.1/vtkCollapseVerticesByArray.h is in libvtk7-dev 7.1.1+dfsg1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkCollapseVerticesByArray.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
/**
 * @class   vtkCollapseVerticesByArray
 * @brief   Collapse the graph given a vertex array
 *
 *
 * vtkCollapseVerticesByArray is a class which collapses the graph using
 * a vertex array as the key. So if the graph has vertices sharing common
 * traits then this class combines all these vertices into one. This class
 * does not perform aggregation on vertex data but allow to do so for edge data.
 * Users can choose one or more edge data arrays for aggregation using
 * AddAggregateEdgeArray function.
 *
 *
*/

#ifndef vtkCollapseVerticesByArray_h
#define vtkCollapseVerticesByArray_h

#include "vtkInfovisCoreModule.h" // For export macro
#include "vtkGraphAlgorithm.h"

class vtkCollapseVerticesByArrayInternal;

class VTKINFOVISCORE_EXPORT vtkCollapseVerticesByArray : public vtkGraphAlgorithm
{
public:
    static vtkCollapseVerticesByArray* New();
    vtkTypeMacro(vtkCollapseVerticesByArray, vtkGraphAlgorithm);

    void PrintSelf(ostream &os, vtkIndent indent);

    //@{
    /**
     * Boolean to allow self loops during collapse.
     */
    vtkGetMacro(AllowSelfLoops, bool);
    vtkSetMacro(AllowSelfLoops, bool);
    vtkBooleanMacro(AllowSelfLoops, bool);
    //@}

    /**
     * Add arrays on which aggregation of data is allowed.
     * Default if replaced by the last value.
     */
    void AddAggregateEdgeArray(const char* arrName);


    /**
     * Clear the list of arrays on which aggregation was set to allow.
     */
    void ClearAggregateEdgeArray();

    //@{
    /**
     * Set the array using which perform the collapse.
     */
    vtkGetStringMacro(VertexArray);
    vtkSetStringMacro(VertexArray);
    //@}


    //@{
    /**
     * Set if count should be made of how many edges collapsed.
     */
    vtkGetMacro(CountEdgesCollapsed, bool);
    vtkSetMacro(CountEdgesCollapsed, bool);
    vtkBooleanMacro(CountEdgesCollapsed, bool);
    //@}

    //@{
    /**
     * Name of the array where the count of how many edges collapsed will
     * be stored.By default the name of array is "EdgesCollapsedCountArray".
     */
    vtkGetStringMacro(EdgesCollapsedArray);
    vtkSetStringMacro(EdgesCollapsedArray);
    //@}


    //@{
    /**
     * Get/Set if count should be made of how many vertices collapsed.
     */
    vtkGetMacro(CountVerticesCollapsed, bool);
    vtkSetMacro(CountVerticesCollapsed, bool);
    vtkBooleanMacro(CountVerticesCollapsed, bool);
    //@}

    //@{
    /**
     * Name of the array where the count of how many vertices collapsed will
     * be stored. By default name of the array is "VerticesCollapsedCountArray".
     */
    vtkGetStringMacro(VerticesCollapsedArray);
    vtkSetStringMacro(VerticesCollapsedArray);
    //@}

protected:

    vtkCollapseVerticesByArray();
   ~vtkCollapseVerticesByArray();

   /**
    * Pipeline function.
    */
   virtual int RequestData(vtkInformation* request,
                           vtkInformationVector** inputVector,
                           vtkInformationVector* outputVector);

   /**
    * Pipeline function.
    */
   virtual int FillOutputPortInformation(int port, vtkInformation* info);


   /**
    * Create output graph given all the parameters. Helper function.
    */
   vtkGraph* Create(vtkGraph* inGraph);

   /**
    * Helper function.
    */
   void FindEdge(vtkGraph* outGraph, vtkIdType source,
                 vtkIdType target, vtkIdType& edgeId);

private:
  //@{
  vtkCollapseVerticesByArray(const vtkCollapseVerticesByArray&) VTK_DELETE_FUNCTION;
  void operator=(const vtkCollapseVerticesByArray&) VTK_DELETE_FUNCTION;
  //@}


protected:
  bool            AllowSelfLoops;
  char*           VertexArray;

  bool            CountEdgesCollapsed;
  char*           EdgesCollapsedArray;

  bool            CountVerticesCollapsed;
  char*           VerticesCollapsedArray;

  vtkCollapseVerticesByArrayInternal* Internal;
};

#endif // vtkCollapseVerticesByArray_h__

APT Browse - Built by Thomas Orozco.