This file is indexed.

/usr/include/dime/entities/Spline.h is in libdime-dev 0.20030921-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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
/**************************************************************************\
 * 
 *  FILE: Spline.h
 *
 *  This source file is part of DIME.
 *  Copyright (C) 1998-1999 by Systems In Motion.  All rights reserved.
 *
 *  This library is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License, version 2, as
 *  published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License (the accompanying file named COPYING) for more
 *  details.
 *
 **************************************************************************
 *
 *  If you need DIME for a non-GPL project, contact Systems In Motion
 *  to acquire a Professional Edition License:
 *
 *  Systems In Motion                                   http://www.sim.no/
 *  Prof. Brochs gate 6                                       sales@sim.no
 *  N-7030 Trondheim                                   Voice: +47 22114160
 *  NORWAY                                               Fax: +47 67172912
 *
\**************************************************************************/

#ifndef DIME_SPLINE_H
#define DIME_SPLINE_H

#include <dime/entities/ExtrusionEntity.h>
#include <assert.h>

class DIME_DLL_API dimeSpline : public dimeEntity
{
public:
  dimeSpline();
  virtual ~dimeSpline();

  enum Flags {
    CLOSED   = 0x01,
    PERIODIC = 0x02, 
    RATIONAL = 0x04,
    PLANAR   = 0x08,
    LINEAR   = 0x10
  };

  bool hasWeights() const;

  int16 getFlags() const;
  void setFlags(const int16 flags);

  int16 getDegree() const;
  void setDegree(const int16 degree);

  dxfdouble getControlPointTolerance() const;
  void setControlPointTolerance(const dxfdouble tol);
  dxfdouble getFitPointTolerance() const;
  void setFitPointTolerance(const dxfdouble tol);
  dxfdouble getKnotTolerance() const;
  void setKnotTolerance(const dxfdouble tol);

  int getNumKnots() const;
  dxfdouble getKnotValue(const int idx) const;
  void setKnotValue(const int idx, const dxfdouble value);
  void setKnotValues(const dxfdouble * const values, const int numvalues,
		     dimeMemHandler * const memhandler = NULL);
  
  int getNumControlPoints() const;
  const dimeVec3f &getControlPoint(const int idx) const;
  void setControlPoint(const int idx, const dimeVec3f &v);
  void setControlPoints(const dimeVec3f * const pts, const int numpts,
			dimeMemHandler * const memhandler = NULL);
  
  int getNumWeights() const;
  dxfdouble getWeight(const int idx) const;
  void setWeight(const int idx, const dxfdouble w,
		 dimeMemHandler * const memhandler = NULL);
  
  int getNumFitPoints() const;
  const dimeVec3f &getFitPoint(const int idx) const;
  void setFitPoint(const int idx, const dimeVec3f &pt);
  void setFitPoints(const dimeVec3f * const pts, const int numpts,
		    dimeMemHandler * const memhandler = NULL);
  
  virtual dimeEntity *copy(dimeModel * const model) const;
  virtual bool getRecord(const int groupcode,
			 dimeParam &param,
			 const int index) const;
  virtual const char *getEntityName() const;

  virtual void print() const;
  virtual bool write(dimeOutput * const out);
  virtual int typeId() const;
  virtual int countRecords() const;
   
protected:
  virtual bool handleRecord(const int groupcode,
			    const dimeParam &param,
                            dimeMemHandler * const memhandler);

private:
  int16 flags;
#ifdef DIME_FIXBIG
  int32 degree;
  int32 numKnots;
  int32 numControlPoints;
  int32 numFitPoints;
#else
  int16 degree;
  int16 numKnots;
  int16 numControlPoints;
  int16 numFitPoints;
#endif
  dxfdouble knotTolerance;
  dxfdouble fitTolerance;
  dxfdouble cpTolerance;
  dxfdouble *knots;
  dxfdouble *weights;
  dimeVec3f *controlPoints;
  dimeVec3f *fitPoints;

  // read/handle counters
  int16 knotCnt;
  int16 fitCnt;
  int16 cpCnt;
  int16 weightCnt;

}; // class dimeSpline

inline int16 
dimeSpline::getFlags() const
{
  return this->flags;
}

inline void 
dimeSpline::setFlags(const int16 flags)
{
  this->flags = flags;
}

inline int16 
dimeSpline::getDegree() const
{
  return this->degree;
}

inline void 
dimeSpline::setDegree(const int16 degree)
{
  this->degree = degree;
}

inline dxfdouble 
dimeSpline::getControlPointTolerance() const
{
  return this->cpTolerance;
}

inline void 
dimeSpline::setControlPointTolerance(const dxfdouble tol)
{
  this->cpTolerance = tol;
}

inline dxfdouble 
dimeSpline::getFitPointTolerance() const
{
  return this->fitTolerance;
}

inline void 
dimeSpline::setFitPointTolerance(const dxfdouble tol)
{
  this->fitTolerance = tol;
}

inline dxfdouble 
dimeSpline::getKnotTolerance() const
{
  return this->knotTolerance;
}

inline void 
dimeSpline::setKnotTolerance(const dxfdouble tol)
{
  this->knotTolerance = tol;
}

inline int 
dimeSpline::getNumKnots() const
{
  return this->numKnots;
}

inline dxfdouble 
dimeSpline::getKnotValue(const int idx) const
{
  assert(idx >= 0 && idx < this->numKnots);
  return this->knots[idx];
}

inline void 
dimeSpline::setKnotValue(const int idx, const dxfdouble value)
{
  assert(idx >= 0 && idx < this->numKnots);
  this->knots[idx] = value;
}

inline int 
dimeSpline::getNumControlPoints() const
{
  return this->numControlPoints;
}

inline const dimeVec3f &
dimeSpline::getControlPoint(const int idx) const
{
  assert(idx >= 0 && idx < this->numControlPoints);
  return this->controlPoints[idx];
}

inline void 
dimeSpline::setControlPoint(const int idx, const dimeVec3f &v)
{
  assert(idx >= 0 && idx < this->numControlPoints);
  this->controlPoints[idx] = v;
}

inline int 
dimeSpline::getNumWeights() const
{
  return this->getNumControlPoints();
}

inline dxfdouble 
dimeSpline::getWeight(const int idx) const
{
  if (this->hasWeights()) {
    assert(idx >= 0 && idx < this->numControlPoints);
    return this->weights[idx];
  }
  return 1.0;
}

inline int 
dimeSpline::getNumFitPoints() const
{
  return this->numFitPoints;
}

inline const dimeVec3f &
dimeSpline::getFitPoint(const int idx) const
{
  assert(idx >= 0 && idx < this->numFitPoints);
  return this->fitPoints[idx];
}

inline void 
dimeSpline::setFitPoint(const int idx, const dimeVec3f &pt)
{
  assert(idx >= 0 && idx < this->numFitPoints);
  this->fitPoints[idx] = pt;
}
 
#endif // ! DIME_SPLINE_H