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
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Authors:
* Bob Jamison <rjamison@titan.com>
*
* Copyright (C) 2004-2006 Bob Jamison
*
* Released under GNU GPL v2+, read the file 'COPYING' for more information.
*/
#ifndef SEEN_TRACE_H
#define SEEN_TRACE_H
# include <cstring>
#include <glibmm/refptr.h>
#include <gdkmm/pixbuf.h>
#include <utility>
#include <vector>
class SPImage;
class SPItem;
class SPShape;
namespace Inkscape {
namespace Trace {
/**
*
*/
class TracingEngineResult
{
public:
/**
*
*/
TracingEngineResult(std::string theStyle,
std::string thePathData,
long theNodeCount) :
style(std::move(theStyle)),
pathData(std::move(thePathData)),
nodeCount(theNodeCount)
{}
TracingEngineResult(const TracingEngineResult &other)
{ assign(other); }
virtual TracingEngineResult &operator=(const TracingEngineResult &other)
{ assign(other); return *this; }
/**
*
*/
virtual ~TracingEngineResult()
= default;
/**
*
*/
std::string getStyle()
{ return style; }
/**
*
*/
std::string getPathData()
{ return pathData; }
/**
*
*/
long getNodeCount()
{ return nodeCount; }
private:
void assign(const TracingEngineResult &other)
{
style = other.style;
pathData = other.pathData;
nodeCount = other.nodeCount;
}
std::string style;
std::string pathData;
long nodeCount;
};
/**
* A generic interface for plugging different
* autotracers into Inkscape.
*/
class TracingEngine
{
public:
/**
*
*/
TracingEngine()
= default;
/**
*
*/
virtual ~TracingEngine()
= default;
/**
* This is the working method of this interface, and all
* implementing classes. Take a GdkPixbuf, trace it, and
* return a style attribute and the path data that is
* compatible with the d="" attribute
* of an SVG <path> element.
*/
virtual std::vector<TracingEngineResult> trace(
Glib::RefPtr<Gdk::Pixbuf> /*pixbuf*/) = 0;
/**
* Abort the thread that is executing getPathDataFromPixbuf()
*/
virtual void abort() = 0;
};//class TracingEngine
/**
* This simple class allows a generic wrapper around a given
* TracingEngine object. Its purpose is to provide a gateway
* to a variety of tracing engines, while maintaining a
* consistent interface.
*/
class Tracer
{
public:
/**
*
*/
Tracer()
{
engine = nullptr;
sioxEnabled = false;
}
/**
*
*/
~Tracer()
= default;
/**
* A convenience method to allow other software to 'see' the
* same image that this class sees.
*/
Glib::RefPtr<Gdk::Pixbuf> getSelectedImage();
/**
* This is the main working method. Trace the selected image, if
* any, and create a <path> element from it, inserting it into
* the current document.
*/
void trace(TracingEngine *engine);
/**
* Abort the thread that is executing convertImageToPath()
*/
void abort();
/**
* Whether we want to enable SIOX subimage selection.
*/
void enableSiox(bool enable);
private:
/**
* This is the single path code that is called by its counterpart above.
* Threaded method that does single bitmap--->path conversion.
*/
void traceThread();
/**
* This is true during execution. Setting it to false (like abort()
* does) should inform the threaded code that it needs to stop
*/
bool keepGoing;
/**
* During tracing, this is Non-null, and refers to the
* engine that is currently doing the tracing.
*/
TracingEngine *engine;
/**
* Get the selected image. Also check for any SPItems over it, in
* case the user wants SIOX pre-processing.
*/
SPImage *getSelectedSPImage();
std::vector<SPShape *> sioxShapes;
bool sioxEnabled;
/**
* Process a GdkPixbuf, according to which areas have been
* obscured in the GUI.
*/
Glib::RefPtr<Gdk::Pixbuf> sioxProcessImage(SPImage *img, Glib::RefPtr<Gdk::Pixbuf> origPixbuf);
Glib::RefPtr<Gdk::Pixbuf> lastSioxPixbuf;
Glib::RefPtr<Gdk::Pixbuf> lastOrigPixbuf;
};//class Tracer
} // namespace Trace
} // namespace Inkscape
#endif // SEEN_TRACE_H
//#########################################################################
//# E N D O F F I L E
//#########################################################################
|
